#include <fstream>

using namespace std;
int n[3], C, a[3][22][2], k=0, nmax;
const int val=1, frecv=0;
ifstream fin("pizza.in");
ofstream fout("pizza.out");

bool ok(int C) /// e ok daca avem o coloana descresc. pe coloana d si celelalte coloane sunt goale
{
    if(n[(C+1)%3]!=0 or n[(C+2)%3]!=0)
        return false; /// nu e ok daca sunt elemente pe alte coloane
    else
        for(int i=0;i<n[C]-1;i++)
            if(a[C][i][val]<a[C][i+1][val])
                return false; /// nu e ok daca coloana nu e descrescatoare de la baza spre varf
    return true;
}

int minim() /// returneaza coloana ce are farfuria cea mai mica in varf
{
    if (a[0][n[0]][val]<=a[1][n[1]][val] and a[0][n[0]][val]<=a[2][n[2]][val])
        return 0;
    if (a[1][n[1]][val]<=a[0][n[0]][val] and a[1][n[1]][val]<=a[2][n[2]][val])
        return 1;
    return 2;
}

int maxim() /// returneaza coloana ce are farfuria cel mai mare in varf
{
    if (a[2][n[2]][val]>=a[1][n[1]][val] and a[2][n[2]][val]>=a[0][n[0]][val])
        return 2;
    if (a[1][n[1]][val]>=a[2][n[2]][val] and a[1][n[1]][val]>=a[0][n[0]][val])
        return 1;
    return 0;
}

int adancime(int x, int y)  /// numarul maxim de farfurii ordonate corect
/// pe coloana x cu toate elementele mai mici sau egale cu farfuria din varful coloanei y
{
    int d=1;
    int k=n[x];
    while (k>1 and a[x][k-1][val]>a[x][k][val] and a[x][k-1][val]<=a[y][n[y]][val])
    {
        --k;
        ++d;
    }
    return d;
}

void hanoi(int deep,int x,int y, int z)
// generam formal mutarile pentru coloana mutata
// cu functia mutare(deep,x,y);
{
    if (deep)
    {
        if (deep==1)
        {
            for(int i=1;i<=a[x][n[x]][frecv];i++)
                fout<<x+1<<" "<<y+1<<endl;
            if (a[x][n[x]][val]==a[y][n[y]][val])
            {
                a[y][n[y]][frecv]+=a[x][n[x]][frecv];
                nmax--;
                n[x]--;
            }
            else
            {
                n[y]++;
                a[y][n[y]][val]=a[x][n[x]][val];
                a[y][n[y]][frecv]=a[x][n[x]][frecv];
                n[x]--;
            }
        }
        else
        {
            hanoi(deep-1,x,z,y);
            for(int i=1;i<=a[x][n[x]][frecv];i++)
                fout<<x+1<<" "<<y+1<<endl;
            if (a[x][n[x]][val]==a[y][n[y]][val])
            {
                a[y][n[y]][frecv]+=a[x][n[x]][frecv];
                nmax--;
                n[x]--;
            }
            else
            {
                n[y]++;
                a[y][n[y]][val]=a[x][n[x]][val];
                a[y][n[y]][frecv]=a[x][n[x]][frecv];
                n[x]--;
            }
            hanoi(deep-1,z,y,x);
        }
    }
}

int main()
{   int deep,i,j,x,y,z;
    a[1][0][val]=999998; a[1][0][frecv]=1;
    a[2][0][val]=999999; a[2][0][frecv]=1;
    a[0][0][val]=999997; a[3][0][frecv]=1;
    for(int i=0;i<3;i++)
    {
        fin>>n[i];
        deep=0;
        for (j=1;j<=n[i];++j)
        {
            fin>>x;
            if(x==a[i][deep][val])
                a[i][deep][frecv]++;     /// farfuriile invecinate cu dimensiuni egale le memoram impreuna, marim frecventa cu 1
            else
            {
                ++deep;                /// creste inaltimea coloanei
                a[i][deep][val]=x;     /// memoram dimensiunea farfuriei
                a[i][deep][frecv]=1;     /// frecventa e 1
            }
        }
        n[i]=deep;  /// numarul de elemente
    }
    nmax=n[0]+n[1]+n[2];
    fin>>C;
    while (!ok(C-1))   /// pozitiile coloanelor din problema sunt 1,2,3, iar in tablou 0, 1, 2
    {
        x=minim(); /// numarul coloanei cu farfuria cea mai mica in varf
        z=maxim(); /// numarul coloanei cu farfuria cea mai mare in varf
        y=3-x-z;  /// numarul tijei care are in varf discul mijlociu
        deep=adancime(x,y);  /// numarul de elemente din vf tijei x, ce sunt mai mic decat discul din varful lui y
        if (deep!=nmax)
        {
            hanoi(deep-1,x,z,y); // se aplica hanoi pentru a genera mutarile necesare infisier
            hanoi(1,x,y,z); // se aplica hanoi pentru a genera mutarile necesare infisier
        }
        else
        {
            hanoi(deep,x,C-1,4-x-C); // se aplica hanoi pentru a genera mutarile necesare infisier
        }
    }
    fout<<"0 0"<<endl;
    fout.close();
    return 0;
}
