#include <fstream>
#include <queue>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

ifstream fin("secv8.in");
ofstream fout("secv8.out");

const int inf= 1<<30;
int cq;

struct tn{
    int left, right;
    int dim, val, pr;
    bool rev;
    tn(){
        left= 0; right= 0;
        val= 0; pr= 0; dim= 0; rev= 0;
    }
};
vector <tn> tr;
queue <int> rec;
int root, tn1, tn2, tn3;

inline void tr_dim(int x){
    tr[x].dim= tr[tr[x].left].dim+tr[tr[x].right].dim+1;
}

void tr_rev(int x){
    if (x==0){
        return;
    }else if (tr[x].rev==1){
        tr[x].rev= 0;
        int aux= tr[x].left; tr[x].left= tr[x].right; tr[x].right= aux;
        tr[tr[x].left].rev^= 1; tr[tr[x].right].rev^= 1;
    }
}

void tr_write(int x){
    if (x==0){
        return;
    }else{
        tr_rev(x);
        tr_write(tr[x].left);
        fout<<tr[x].val<<" ";
        tr_write(tr[x].right);
        
    }
}

int tr_rleft(int x){
    int aux= tr[x].left;
    tr_rev(aux);
    tr[x].left= tr[aux].right; tr_dim(x);
    tr[aux].right= x; tr_dim(aux);
    return aux; 
}

int tr_rright(int x){
    int aux= tr[x].right;
    tr_rev(aux);
    tr[x].right= tr[aux].left; tr_dim(x);
    tr[aux].left= x; tr_dim(aux);
    return aux;
}

int tr_balance(int x){
    if (tr[x].pr<tr[tr[x].left].pr){
        return tr_rleft(x);
    }
    if (tr[x].pr<tr[tr[x].right].pr){
        return tr_rright(x);
    }
    return x;
}

int tr_ins(int x, int pos, int val, int pr){
    if (x==0){
        if (rec.empty()==1){
            x= tr.size();
            tr.push_back(tn());
        }else{
            x= rec.front();
            tr[x]= tn();
            rec.pop();
        }
        tr[x].val= val; tr[x].pr= pr; tr[x].dim= 1;  
    }else{
        tr_rev(x);
        if (pos<=tr[tr[x].left].dim+1){
            int aux= tr_ins(tr[x].left, pos, val, pr); 
            tr[x].left= aux;
        }else{
            int aux= tr_ins(tr[x].right, pos-tr[tr[x].left].dim-1, val, pr);
            tr[x].right= aux;
        }
        x= tr_balance(x);
        tr_dim(x);
    }
    return x;
}

int tr_que(int x, int pos){
    tr_rev(x);
    if (pos==tr[tr[x].left].dim+1){
        return tr[x].val;
    }else if (pos<=tr[tr[x].left].dim){
        return tr_que(tr[x].left, pos);
    }else{
        return tr_que(tr[x].right, pos-tr[tr[x].left].dim-1);
    }
}

void tr_spl(int x, int y){
    root= tr_ins(root, x, 0, inf);
    tn1= tr[root].left; root= tr[root].right;
    root= tr_ins(root, y-x+2, 0, inf);
    tn2= tr[root].left; tn3= tr[root].right;
}

int tr_erase(int x){
    tr_rev(x);
    if (tr[x].left==0&& tr[x].right==0){
        rec.push(x);
        return 0;
    }else if (tr[tr[x].left].pr>tr[tr[x].right].pr){
        x= tr_rleft(x); 
        tr[x].right= tr_erase(tr[x].right);
    }else{
        x= tr_rright(x);
        tr[x].left= tr_erase(tr[x].left);
    }
    tr_dim(x);
    return x;
}

int tr_join(int x, int y){
    int aux;
    if (rec.empty()==1){
        aux= tr.size(); 
        tr.push_back(tn());
    }else{
        aux= rec.front();
        tr[aux]= tn();
        rec.pop();
    }
    tr[aux].left= x; tr[aux].right= y;
    aux= tr_erase(aux);
    return aux;
}

int main(){
    int nq, ifr;
    fin>>nq>>ifr;

    tr.push_back(tn());
    root= 0;
    srand(time(0));
    for (cq= 1; cq<=nq; ++cq){
        char op;
        fin>>op;
        if (op=='I'){
            int x, y;
            fin>>x>>y;
            root= tr_ins(root, x, y, rand()%(inf-1));
        }else if (op=='A'){
            int x;
            fin>>x;
            fout<<tr_que(root, x)<<"\n";
        }else if (op=='R'){
            int x, y;
            fin>>x>>y;
            tr_spl(x, y); 
            tr[tn2].rev= 1;
            root= tr_join(tn1, tn2); root= tr_join(root, tn3);
        }else{
            int x, y;
            fin>>x>>y;
            tr_spl(x, y);
            root= tr_join(tn1, tn3);
        }
    }
    tr_write(root); printf("\n");

    return 0;
}