#include <bits/stdc++.h>

using namespace std;

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

class Treap
{
public:
	int val;
	int prior;

	array <Treap*,2> sons;

	int sz;

	bool rev;

	Treap(int _val,Treap *l,Treap *r);
} *T,*t;

int sz(Treap *T)
{
    if(T==NULL)
        return 0;

    return T->sz;
}

void recalc(Treap *T)
{
	if (T==NULL)
        return;

	T->sz=1;

	for (auto son:T->sons)
        if (son!=NULL)
            T->sz+=son->sz;
}

Treap::Treap(int _val,Treap *l,Treap *r)
{
    sons={l,r};

    sz=1;

    val=_val;

    rev=0;

    srand(time(0));

    prior=rand()%1000000000;

    recalc(this);
}

void prop(Treap *T);

Treap* Merge(Treap *l,Treap *r);

void prop(Treap *T)
{
	if (sz(T)<=1)
        return;

	if (T->rev==0)
        return;

	for (auto son:T->sons)
        if (son!=NULL)
            son->rev^=1;

    swap(T->sons[0],T->sons[1]);

	T->rev=0;
}

void Print(Treap *T)
{
    if(T==NULL)
        return;

    prop(T);

    Print(T->sons[0]);

    fout<<T->val<<" ";

    Print(T->sons[1]);
}

Treap* Merge(Treap *l,Treap *r)
{
	if (l==NULL)
        return r;

	if (r==NULL)
        return l;

	prop(l);
	prop(r);

	if (l->prior>r->prior)
    {
		l=new Treap(l->val,l->sons[0],Merge(l->sons[1],r));

		return l;
	}
	else
	{
		r=new Treap(r->val,Merge(l,r->sons[0]),r->sons[1]);

		return r;
	}
}

array <Treap*,2> split(Treap *T,int ind)
{
	if (T==NULL)
        return {NULL,NULL};

    if(T->sz==1)
    {
        if(ind==1)
        {
            return {T,NULL};
        }
        else
        {
            return {NULL,T};
        }
    }

	prop(T);

	if (sz(T->sons[0])>=ind)
    {
        array <Treap*,2> aux=split(T->sons[0],ind);

		T->sons[0]=aux[1];

		recalc(T);

		return {aux[0],T};
	}
	else
	{
        ind-=sz(T->sons[0])+1;

		array <Treap*,2> aux=split(T->sons[1],ind);

        T->sons[1]=aux[0];

		recalc(T);

		return {T,aux[1]};
	}

	return {NULL,NULL};
}

Treap* Insert(Treap *T,int k,int v)
{
    t=new Treap(v,NULL,NULL);

    array <Treap*,2> a=split(T,k-1);

    return Merge(a[0],Merge(t,a[1]));
}

int valAtPos(Treap *T,int pos1,int pos2)
{
    if(T==NULL)
        return 0;

    prop(T);

    if(T->sz==1)
        return T->val;

    int aux=pos2+T->sons[0]->sz;

    if(aux>=pos1)
        return valAtPos(T->sons[0],pos1,pos2);

    if(aux+1==pos1)
        return T->val;

    return valAtPos(T->sons[1],pos1,aux+1);
}

Treap* Reverse(Treap *T,int l,int r)
{
    array <Treap*,2> a=split(T,l-1);
	array <Treap*,2> b=split(a[1],r-l+1);

	if(b[0]!=NULL)
    {
        b[0]->rev=1;

        prop(b[0]);
    }

	return Merge(a[0],Merge(b[0],b[1]));
}

Treap* Delete(Treap *T,int l,int r)
{
    array <Treap*,2> a=split(T,l-1);
	array <Treap*,2> b=split(a[1],r-l+1);

	return Merge(a[0],b[1]);
}

int q;

bool c;

int main()
{
    fin>>q>>c;

    while(q--)
    {
        char tip;
        fin>>tip;

        if(tip=='I')
        {
            int k,v;
            fin>>k>>v;

            T=Insert(T,k,v);
        }

        if(tip=='A')
        {
            int k;
            fin>>k;

            fout<<valAtPos(T,k,0)<<"\n";
        }

        if(tip=='R')
        {
            int i,j;
            fin>>i>>j;

            T=Reverse(T,i,j);
        }

        if(tip=='D')
        {
            int i,j;
            fin>>i>>j;

            T=Delete(T,i,j);
        }
    }

    Print(T);

    fout<<"\n";

	return 0;
}