#include <fstream>
#include <stdlib.h>
#include <bits/stdc++.h>
using namespace std;
ifstream fin("secv8.in");
ofstream fout("secv8.out");

const int INF = 2e9;

struct node{
int v = 0;
int p = 0;
int c = 0;
int rev = 0;
node* l;
node* r;

node()=default;
node(int _v,int _p,int _c,int _rev,node* _l,node* _r)
{
    v = _v,p=_p,c=_c,rev=_rev,l=_l,r=_r;
}

};


node *root,*nul;

void update(node* &nod)
{
    if (nod == nul)
        return;
    if(nod->rev)
    {
        if(nod->l != nul)   nod->l->rev = 1-nod->l->rev;
        if(nod->r != nul)   nod->r->rev = 1-nod->r->rev;
        swap(nod->l,nod->r),nod->rev = 0;
    }
    nod->c = 1 + nod->l->c + nod->r->c;
}

void rot_right(node* &nod)
{
    node* lc = nod->l;
    nod->l = lc->r;lc->r=nod;
    nod = lc;
}
void rot_left(node* &nod)
{
    node* rc = nod->r;
    nod->r = rc->l;rc->l=nod;
    nod = rc;
}
void balance(node* &nod)
{
    if(nod==nul)
        return;
    update(nod);
    update(nod->l);
    update(nod->r);
    if(nod->p < nod->l->p)
    {
        rot_right(nod);
        update(nod->r);
        update(nod);
    }
    else if (nod->p < nod->r->p)
    {
        rot_left(nod);
        update(nod->l);
        update(nod);
    }
}

void insert(node* &nod,int poz,node* ins)
{
    if(nod==nul)
    {
        nod = ins;
        nod->l = nul;
        nod->r = nul;
        return;
    }
    update(nod);
    if(poz > nod->l->c + 1)
        insert(nod->r,poz - nod->l->c - 1,ins);
    else
        insert(nod->l,poz,ins);
    update(nod);
    balance(nod);

}
void erase(node* &nod,int val)
{
    update(nod);
    if(nod->l == nul && nod->r == nul)
    {
        if(nod->v == val)
            delete nod,nod=nul;
        return;
    }
    if(nod->l->p > nod->r->p)
    {
        update(nod->l);
        rot_right(nod);
        erase(nod->r,val);
        update(nod);
    }
    else
    {
        update(nod->r);
        rot_left(nod);
        erase(nod->l,val);
        update(nod);
    }
    update(nod);
}
node *a,*b,*c,*d;
// how many in first
void split(node* nod,int pos,node* &ls,node* &rs)
{
    update(nod);
    insert(nod,pos+1,new node(INF,INF,1,0,nul,nul));
    ls = nod->l;
    rs = nod->r;
    delete nod;
}
void merge(node* l,node* r,node* &rez)
{
    node* x = new node(INF,-1,l->c + r->c,0,l,r);
    erase(x,INF);
    rez = x;
}

void print(node* nod)
{
    update(nod);
    if(nod==nul)
        return;
    print(nod->l);
    fout<<nod->v<<' ';
    print(nod->r);
}
void reverse(node*& nod,int l,int r)
{

    split(nod,l-1,a,b);
    split(b,r-l+1,c,d);
    c->rev=1;
    update(c);
    merge(c,d,b);
    merge(a,b,nod);
}
void del(node*& nod,int l,int r)
{
    split(nod,l-1,a,b);
    split(b,r-l+1,c,d);
    merge(a,d,nod);
}
int acces(node* nod,int poz)
{
    if(nod->l->c + 1 == poz)
        return nod->v;
    if(nod->l->c + 1 > poz)
        return acces(nod->l,poz);
    return acces(nod->r,poz - nod->l->c - 1);
}






int main()
{
    srand(time(0));
    root = nul = new node();
   // 2 1 3 4
    int n,q;
    fin>>n>>q;
    for(int i=1;i<=n;i++)
    {
        char op;
        fin>>op;
        if(op=='I')
        {
            int a,b;
            fin>>a>>b;
            insert(root,a,new node(b,rand(),1,0,nul,nul));
        }
        else if (op=='A')
        {
            int p;
            fin>>p;
            fout<<acces(root,p)<<'\n';
        }
        else if(op=='R')
        {
            int st,dr;
            fin>>st>>dr;
            reverse(root,st,dr);
        }
        else if(op=='D')
        {
            int st,dr;
            fin>>st>>dr;
            del(root,st,dr);
        }
    }
    print(root);
}