#include <fstream>
#include <iostream>
#include <stdlib.h>
using namespace std;

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

const int INF = 1e9;





struct trnod{
int val = 0;
int pri = 0;
int ch = 0;
int rvs = 0;
trnod* left = NULL;
trnod* right = NULL;
trnod(int pr,int v,int c,int rv,trnod*l,trnod*r)
{
    pri=pr,val=v,ch=c,rvs=rv,left=l,right=r;
}
trnod() = default;

};

trnod* root,*nul;
trnod* a;
trnod* b;
trnod* c;

void update(trnod* node)
{
    if(node==nul)
        node->ch=0;
    else{
        node->ch = node->left->ch + node->right->ch + 1;
        if(node->rvs)
        {
            node->left->rvs = 1-node->left->rvs;
            node->right->rvs = 1-node->right->rvs;
            swap(node->left,node->right);
            node->rvs=0;
        }
    }
}

void rot_right(trnod* &node)
{
    trnod* l = node->left;
    node->left = l->right,l->right = node;
    node = l;
}
void rot_left(trnod* &node)
{
    trnod* r = node->right;
    node->right = r->left,r->left = node;
    node = r;
}

void balance(trnod* &node)
{
    if(node->pri < node->left->pri)
    {
        rot_right(node);
        update(node->right);
        update(node);
    }
    else if (node->pri < node->right->pri)
    {
        rot_left(node);
        update(node->left);
        update(node);
    }



}
void insert(trnod* &nod,int pos,int pr,int v,int ch,int rv)
{
    if(nod == nul)
    {
        nod = new trnod(pr,v,1,0,nul,nul);
        update(nod);
        return;
    }
    update(nod);
    if(nod->left->ch + 1 >= pos)    insert(nod->left,pos,pr,v,ch,rv);
    else     insert(nod->right,pos-nod->left->ch-1,pr,v,ch,rv);
    update(nod);
    balance(nod);
}
trnod* acces(trnod* nod,int pos)
{
    update(nod);
    if(nod->left->ch + 1 == pos)
        return nod;
    if(nod->left->ch+1 > pos)
        return acces(nod->left,pos);
    return acces(nod->right,pos-nod->left->ch-1);
}

void erase(trnod* &nod,int val)
{
    if(nod->left==nul && nod->right==nul){
        if(nod->val == val)
            delete nod,nod=nul;
        return;
    }
    update(nod);
    update(nod->left);
    update(nod->right);
    if(nod->left->pri > nod->right->pri)
    {
        rot_right(nod);
        erase(nod->right,val);
    }
    else
    {
        rot_left(nod);
        erase(nod->left,val);
    }
    update(nod);
}
void split(trnod* nod,int pos,trnod* &l,trnod* &r)
{
    insert(nod,pos,INF,INF,0,0);
    l=nod->left;
    r=nod->right;
    delete nod;
}
void join(trnod* &nod,trnod* l,trnod* r){
    nod = new trnod(-1,INF,l->ch+r->ch,0,l,r);
    erase(nod,INF);
}

void df_in(trnod* nod)
{
    if(nod!=nul)
    {
        update(nod);
        df_in(nod->left);
        fout<<nod->val<<' ';
        df_in(nod->right);
    }
}
int n,k;
int main()
{

    root = nul = new trnod(0, 0, 0, 0, NULL, NULL);
    a = nul;
    b = nul;
    c = nul;
    fin>>n>>k;
    for(int i=1;i<=n;i++)
    {
        char op;
        fin>>op;
        if(op=='A')
        {
            int p;
            fin>>p;
            fout<<(acces(root,p)->val)<<'\n';
            continue;
        }
        if(op=='I')
        {
            int p,v;
            fin>>p>>v;
            insert(root,p,rand(),v,0,0);
            continue;
        }
        if(op=='R')
        {
            int st,dr;
            fin>>st>>dr;
            //trnod* a = new trnod;
            //trnod* b = new trnod;
            //trnod* c = new trnod;
            split(root,dr+1,a,b);
            split(a,st,c,root);
            root->rvs=1;
            join(a,c,root);
            join(root,a,b);
            continue;
        }
        if(op=='D')
        {
            int st,dr;
            fin>>st>>dr;
            split(root,dr+1,a,b);
            split(a,st,c,root);
            join(root,c,b);
        }

    }
    df_in(root);
}