#include<iostream>
#include<string>
using namespace std;

typedef struct Aktor{
        int raz,dwa;
        string pierwszy,drugi;
        struct Aktor *next,*prev;
} A;

class Las{
        int ile;
        public:
        Las(){
                glowa=ogon=NULL;
                ile=0;
        }
        ~Las(){}
        void dodaj(string x,string y,int a,int b){
                A * nowy=new Aktor;
                nowy->raz=a;
                nowy->dwa=b;
                nowy->pierwszy=x;
                nowy->drugi=y;
                nowy->next=NULL;
                if(!ile){
                        ile++;
                        nowy->prev=NULL;
                        glowa=ogon=nowy;
                }
                else{
                        ile++;
                        ogon->next=nowy;
                        nowy->prev=ogon;
                        ogon=nowy;
                }
        }
        void przejdz(int k){
                A * n=glowa;
                int i=0;
                while(n){
                        if(i==k){cout<<n->pierwszy<<endl<<n->drugi<<endl<<n->raz<<endl<<n->dwa<<endl;}
                        i++;
                        n=n->next;

                }
        }


        A * mid(int p,int k,A *x){
        A *n=x;
        int i=p;
        //x(p)

        while(n){
        if (i==k){
        break;
        }
        n=n->next;
        i++;
        }
        return n;

        }

        A * getogon(){return ogon;}
        A * getglowa(){return glowa;}
        void setogon(A * o){ogon=o;}
        void setglowa(A*g){glowa=g;}
int getile(){return ile;}
        private:
        A * glowa,*ogon;
};
int jeden,drugi;
string raz,dwa;
void swap(A *x,A* y){
        raz=x->pierwszy,dwa=x->drugi;
        jeden=x->raz,drugi=x->dwa;
        x->raz=y->raz;
        x->dwa=y->dwa;
        x->pierwszy=y->pierwszy;
        x->drugi=y->drugi;

        y->raz=jeden;
        y->dwa=drugi;
        y->pierwszy=raz;
        y->drugi=dwa;


}

void quick(Las las,A *left,A*right){
        if (left!=right){
                A * m=left;
                A *i;
                i=left->next;
                while(i&&i!=right->next){
                        if(i->pierwszy<left->pierwszy){
                                m=m->next;
                                swap(m,i);

                        }
                                i=i->next;
                }
if(left&&m&&left!=m)    swap(left,m);

if(left&&m->prev&&left!=m)quick(las,left,m->prev);
if(m->next&&right&&m!=right)quick(las,m->next,right);

        }


}
Las scal(Las raz,Las dwa){
        Las *pomocniczy=new Las();
A *i=raz.getglowa(),*j=dwa.getglowa();
while(i!=NULL||j!=NULL){

        if((j!=NULL&i!=NULL&i->drugi<=j->drugi)|(j==NULL&i!=NULL)) {pomocniczy->dodaj(i->pierwszy,i->drugi,i->raz,i->dwa); i=i->next;}
else if((j!=NULL&i!=NULL&i->drugi>j->drugi)|(i==NULL&j!=NULL)){pomocniczy->dodaj(j->pierwszy,j->drugi,j->raz,j->dwa); j=j->next;}

}
return *pomocniczy;
}


Las merge(Las &las,A * left,A * right,int p,int k){
        Las tm;
        if(left==right) {Las ble;ble.dodaj(left->pierwszy,left->drugi,left->raz,left->dwa);return ble;}
        if (left!=right){

int ble=(p+k)/2;
        A* m=las.mid(p,ble,left);
        Las tm1,tm2;
        tm1=merge(las,left,m,p,ble);
        tm2=merge(las,m->next,right,ble+1,k);
tm=scal(tm1,tm2);

        }
        return tm;
}




int main(){
        int n,k;
        int tmpile;

        Las cos;
        string pusty,pierwsze,drugie;
        int wybor,raz,dwa;
        cin>>n;
        while(n){
                cin>>wybor;
                switch(wybor){
                        case 1:{
                                                         getline(cin,pusty);
                                                 getline(cin,pierwsze);
                                         getline(cin,drugie);
                                                 cin>>raz>>dwa;
                                                         cos.dodaj(pierwsze,drugie,raz,dwa);
                                                         break;}
                        case 2:{
                                                         quick(cos,cos.getglowa(),cos.getogon());
                                                         break;}
                        case 3:{

                                                         tmpile=cos.getile()-1;
                                                         cos=merge(cos,cos.getglowa(),cos.getogon(),0,tmpile);
                                                         break;}
                        case 4:{
                                                         cin>>k;
                                                         cos.przejdz(k);

                                                         break;}
                        default: break;

                }
                n--;}
                return 0;}