#include <cstdio>
#include <algorithm>
#include <random>
#include <chrono>

using namespace std;

FILE *f = fopen("secv8.in","r");
FILE *g = fopen("secv8.out","w");

struct treap{
    int key,prio;
    treap *l,*r;
    int sz;
    bool rev;
    
    treap(int key,int prio,treap *l,treap *r,int sz,bool rev){
        this->key = key;
        this->prio = prio;
        this->l = l;
        this->r = r;
        this->sz = sz;
        this->rev = rev;
    }

    void propag(){
        l->rev ^= rev;
        r->rev ^= rev;
        if(rev){
            swap(l,r);
            rev = 0;
        }
    }

    void recalc(){
        sz = l->sz + r->sz + 1;
    }
}*root,*nill;



void afis(treap *t){
    if(t == nill)return ;
    t->propag();
    afis(t->l);
    fprintf(g,"%d ",t->key);
    afis(t->r);
}

treap* join(treap *t1,treap *t2){

    if(t1 == nill){
        return t2;
    }
    if(t2 == nill){
        return t1;
    }

    t1->propag();
    t2->propag();

    if(t1->prio >= t2->prio){
        t1->r = join(t1->r,t2);
        t1->recalc();
        return t1;
    }
    else{
        t2->l = join(t1,t2->l);
        t2->recalc();
        return t2;
    }
}

pair<treap*,treap*> split(treap *t,int pos){
    pair<treap*,treap*> ans = {nill,nill};

    if(t == nill){
        return ans;
    }

    t->propag();
    
    if(t->l->sz + 1 <= pos){
        pair<treap*,treap*> tmp = split(t->r,pos - 1 - t->l->sz);
        t->r = tmp.first;
        t->recalc();
        ans.first = t;
        ans.second = tmp.second;
        return ans;
    }
    else{
        pair<treap*,treap*> tmp = split(t->l,pos);
        t->l = tmp.second;
        t->recalc();
        ans.first = tmp.first;
        ans.second = t;
        return ans;
    }
}

treap* insert(treap *t,int pos,treap *elem){
    pair<treap*,treap*> tmp = split(t,pos - 1);
    t = join(tmp.first,elem);
    t = join(t,tmp.second);
    return t;
}

treap* access(treap *t,int pos){
    t->propag();

    if(pos <= t->l->sz){
        return access(t->l,pos);
    }
    else if(pos == t->l->sz + 1){
        return t;
    }
    else{
        return access(t->r,pos - 1 - t->l->sz);
    }
}

treap* rev(treap *t,int l,int r){
    pair<treap*,treap*> tmp = split(t, l - 1);
    pair<treap*,treap*> aux = split(tmp.second, r - l + 1);
    aux.first->rev ^= 1;
    t = join(tmp.first,join(aux.first,aux.second));
    return t;
}

treap* rem(treap *t,int l,int r){
    pair<treap*,treap*> tmp = split(t, l - 1);
    pair<treap*,treap*> aux = split(tmp.second, r - l + 1);
    t = join(tmp.first,aux.second);
    return t;
}

int main(){

    nill = new treap(0,-1,NULL,NULL,0,0);
    root = nill;

    mt19937 gen(chrono::steady_clock::now().time_since_epoch().count());

    int n,t;

    fscanf(f,"%d %d\n",&n,&t);

    for(int i = 1;i <= n;i++){
        char op;
        int j,k;
        fscanf(f,"%c ",&op);

        if(op == 'I'){
            fscanf(f,"%d %d\n",&j,&k);
            treap* tmp = new treap(k,(int)gen(),nill,nill,1,0);
            root = insert(root,j,tmp);
        }
        else if(op == 'A'){
            fscanf(f,"%d\n",&j);
            fprintf(g,"%d\n",access(root,j)->key);
        }
        else if(op == 'R'){
            fscanf(f,"%d %d\n",&j,&k);
            root = rev(root,j,k);
        }
        else{
            fscanf(f,"%d %d\n",&j,&k);
            root = rem(root,j,k);
        }
    }

    afis(root);

    fclose(f);
    fclose(g);

    return 0;
}