#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <time.h>
#define INF 1000000000
using namespace std;
ifstream fin ("date.in");
ofstream fout("date.out");
int nr,ok,x,y,t;
char c;
struct T{
    int val;int heap;int n;int rev;
    T *st, *dr;
    T(int val, int heap, T *st, T *dr, int n,int rev)
    {
        this->val=val;
        this->heap=heap;
        this->st=st;this->dr=dr;
        this->n=n;
        this->rev=rev;
    }
} *nod,*nil, *ts, *td, *ta;
void updateReversed(T *nod) {
    if (nod->rev==1&&nod!=nil) {
        nod->st->rev=1-nod->st->rev;
        nod->dr->rev=1-nod->dr->rev;
        T *aux=nod->st;
        nod->st=nod->dr;
        nod->dr=aux;
        nod->rev=0;
    }
}
int Rand()
{
    return 1 + (((rand()%32768)<<15) + rand()%32768 + 1 );
}
void refresh(T *nod) {
    if(nod==nil) nod->n=0;
    else nod->n=nod->st->n+nod->dr->n+1;
}
void turnright(T *&nod) {
    T *t=nod->st;
    nod->st=t->dr;t->dr=nod;
    nod=t;
    refresh(nod->dr);
    refresh(nod);
}
void turnleft(T* &nod) {
    T *t=nod->dr;
    nod->dr=t->st;t->st=nod;
    nod=t;
    refresh(nod->st);
    refresh(nod);
}
void balance(T* &nod) {
    if(nod->st!=NULL&&nod->st->heap>nod->heap) turnright(nod);
    else if(nod->dr!=NULL&&nod->dr->heap>nod->heap) turnleft(nod);
}
void in(T *&nod,int val,int heap,int poz)
{
    if(nod==nil)
    {
        nod=new T(val,heap,nil,nil,1,0);nr++;
        return;
    }
    updateReversed(nod);
    if(nod->st->n>=poz-1) in(nod->st,val,heap,poz);
    else in(nod->dr,val,heap,poz-nod->st->n-1);
    balance(nod);
    refresh(nod);
}
T *acces(T *nod,int poz)
{
    updateReversed(nod);
    refresh(nod);
    if(nod->st->n==poz-1) return nod;
    else if(nod->st->n>poz-1) return acces(nod->st,poz);
    else return acces(nod->dr,poz-nod->st->n-1);

}
void out(T *&nod,int val)
{
    if(nod->st==nil&&nod->dr==nil)
    {
        if(nod->val==val)
        {
            delete nod;
            nod=nil;
        }
    }else{
        updateReversed(nod);
        if(nod->st->heap>nod->dr->heap)
        {
            updateReversed(nod->st);
            turnright(nod);
            out(nod->dr,val);
        }else{
            updateReversed(nod->dr);
            turnleft(nod);
            out(nod->st, val);

        }
        refresh(nod);
    }
}
void split(T *nod,int poz, T *&ts,T *&td)
{
    in(nod,INF,INF,poz);
    ts=nod->st;
    td=nod->dr;
    delete nod;
}
void join(T *&nod, T *ts, T *td)
{
    nod=new T(INF,-1,ts,td,ts->n+td->n,0);
    out(nod,INF);

}
void dfs(T *&nod)
{
    if(nod==nil) return;
    updateReversed(nod);
    refresh(nod);
    dfs(nod->st);
    fout<<nod->val<<" ";
    dfs(nod->dr);
}
int main ()
{
    srand(time(0));
    nod=nil=new T(0, 0, NULL, NULL, 0, 0);
    fin>>t>>ok;
    for(;t--;)
    {
        fin>>c;
        //show(nod,0);cout<<"\n";
        if(c=='I')
        {
            fin>>y;fin>>x;
            in(nod,x,Rand(),y);
        }
        if(c=='A')
        {
            fin>>y;
            ta=acces(nod,y);
            fout<<ta->val<<"\n";
            continue;
        }
        if(c=='D')
        {
            fin>>x>>y;
            split(nod,y+1,ta,td);
            split(ta,x,ts,nod);
            join(nod,ts,td);
        }
        if(c=='R')
        {
            fin>>x>>y;
            split(nod,y+1,ta,td);
            split(ta,x,ts,nod);
            nod->rev = 1;
            join(ta,ts,nod);
            join(nod,ta,td);
        }
    }
    dfs(nod);
    return 0;
}