#include<bits/stdc++.h>
using namespace std;

struct Treap
{
    int key;
    int priority;
    int weight;
    int reversed;
    Treap *left,*right;
    Treap(int priority,int key,int weight,int reversed,Treap *left, Treap *right)
    {
        this->key=key;
        this->priority=priority;
        this->weight=weight;
        this->reversed=reversed;
        this->left=left;
        this->right=right;
    }
}*root,*nil,*L,*R,*aux;


int n,asd,pos,val;
char op;
const int inf=2000000000;

void update_reversed(Treap* root)
{
    if(root->reversed && root!=nil)
    {
        root->left->reversed=1-root->left->reversed;
        root->right->reversed=1-root->right->reversed;
        root->reversed=0;
        Treap* aux=root->left;
        root->left=root->right;
        root->right=aux;
    }
}
void setup()
{
    srand(time(0));
    root=nil=new Treap(0,0,0,0,NULL,NULL);
}

void rotright(Treap* &root)
{
    Treap* w=root->left;
    root->left=w->right;
    w->right=root;
    root=w;
}

void rotleft(Treap* &root)
{
    Treap* w=root->right;
    root->right=w->left;
    w->left=root;
    root=w;
}

void update_weight(Treap* root)
{
    if(root==nil) root->weight=0;
        else
    root->weight=1+ root->left->weight + root->right->weight;
}

void balance(Treap* &root)
{
    if( root->left->priority > root->priority )
    {
        rotright(root);
        update_weight(root->right);
        update_weight(root);
    }
        else
    if(root->right->priority > root->priority)
    {
        rotleft(root);
        update_weight(root->left);
        update_weight(root);
    }
}

void insert_node(Treap* &root,int pos,int priority,int key)
{
    if(root==nil)
    {
        root=new Treap(priority,key,1,0,nil,nil);
       // return;
    }
        else
    {
        update_reversed(root);

        if(root->left->weight>=(pos-1)) insert_node(root->left,pos,priority,key);
            else insert_node(root->right,pos-root->left->weight-1,priority,key);

        balance(root);
        update_weight(root);
    }
}

Treap* access(Treap* root,int pos)
{
    update_reversed(root);
    update_weight(root);

    if(root->left->weight==(pos-1)) return root;
        else
    if(root->left->weight>(pos-1)) return access(root->left,pos);
        else return access(root->right,pos-root->left->weight-1);
}

void erase_node(Treap* &root,int key)
{
    if(root->left==nil && root->right==nil)
    {
        if(root->key==key)
        {
            delete root;
            root=nil;
        }
    }
        else
    {
        update_reversed(root);
        if(root->left->priority>root->right->priority)
        {
            update_reversed(root->left);
            rotright(root);
            erase_node(root->right,key);
        }
            else
        {
            update_reversed(root->right);
            rotleft(root);
            erase_node(root->left,key);
        }

        update_weight(root);
    }
}
void split(Treap* root,int pos,Treap* &L,Treap* &R)
{
    insert_node(root,pos,inf,inf);
    L=root->left;
    R=root->right;
    delete root;
}

void join(Treap* &root,Treap *L,Treap *R)
{
    root=new Treap(-1,inf,L->weight+R->weight,0,L,R);
    erase_node(root,inf);
}
void solve (Treap* root)
{
    if(root==nil) return;
    update_reversed(root);
    update_weight(root);
    solve(root->left);
    printf("%d ",root->key);
    solve(root->right);
}
int Rand()
{
    return 1 + (((rand()%32768)<<15) + rand()%32768 + 1 );
}

int main()
{
    freopen("secv8.in","r",stdin);
    freopen("secv8.out","w",stdout);

    scanf("%d%d",&n,&asd);

    setup();

    while(n--)
    {
        scanf("\n");
        scanf("%c",&op);
        if(op=='I')
        {
            scanf("%d%d",&pos,&val);
            insert_node(root,pos,Rand(),val);
        }
            else

        if(op=='A')
        {
            scanf("%d",&pos);
            Treap *node=access(root,pos);
            printf("%d\n",node->key);
        }
            else
        if(op=='R')
        {
            int i,j;
            scanf("%d%d",&i,&j);
            split(root,j+1,aux,R);
            split(aux,i,L,root);
            root->reversed^=1;
            join(aux,L,root);
            join(root,aux,R);
        }
            else
        if(op=='D')
        {
            int i,j;
            scanf("%d%d",&i,&j);
            split(root,j+1,aux,R);
            split(aux,i,L,root);
            join(root,L,R);
        }
    }

   // cerr<<root->weight<<'\n';
    solve(root);

    return 0;
}