#include <cstdio>

 #include <cstdlib>

 #include <cstring>

 const int size=;

 const int inf=0x7FFFFFFF;

 template <class type>

 inline void swap(type & a, type & b)

     {type t=a; a=b; b=t;}

 namespace treap

 {

     struct node

     {

         char ch; int size;

         int weight;

         bool rev;

         node * left, * right;

         inline node():size() {left=right=this;}

         inline void pushdown() {if (rev) swap(left, right), left->rev^=, right->rev^=, rev=;}

         inline void maintain() {size=left->size+right->size+;}

     };

     node * null=new node();

     node MEM[size], * PORT=MEM;

     inline node * newnode(char ch, int size)

     {

         node * ret=PORT++;

         ret->ch=ch; ret->size=size;

         ret->rev=;

         ret->left=ret->right=null;

         return ret;

     }

     node * newtreap(char * s, int l, int w)

     {

         if (!l) return null;

         node * ret=newnode(s[l>>], l);

         ret->weight=rand()%w+;

         if (l==) return ret;

         ret->left=newtreap(s, l>>, ret->weight);

         ret->right=newtreap(s+(l>>)+, l-(l>>)-, ret->weight);

         return ret;

     }

     void split(node * t, int k, node *& l, node *& r)

     {

         if (t==null) l=r=null;

         else

         {

             t->pushdown();

             if (t->left->size<k)

             {

                 l=t;

                 split(t->right, k-t->left->size-, t->right, r);

                 l->maintain();

             }

             else

             {

                 r=t;

                 split(t->left, k, l, t->left);

                 r->maintain();

             }

         }

     }

     node * merge(node * l, node * r)

     {

         if (l==null) return r;

         if (r==null) return l;

         if (l->weight>r->weight)

         {

             l->pushdown();

             l->right=merge(l->right, r);

             l->maintain();

             return l;

         }

         else

         {

             r->pushdown();

             r->left=merge(l, r->left);

             r->maintain();

             return r;

         }

     }

 }

 int N, mouse;

 char str[size];

 treap::node * root=treap::newnode(' ', );

 void print(treap::node * );

 inline void insert(char * , int);

 inline void remove(int);

 inline void rotate(int);

 inline char get();

 int main()

 {

     int x;

     scanf("%d", &N); mouse=;

     root->weight=rand();

     for ( ;N;N--)

     {

         scanf("%s", str);

         if (str[]=='G') putchar(get()), putchar('\n');

         else if (str[]=='M') scanf("%d", &x), mouse=x;

         else if (str[]=='P' && mouse) mouse--;

         else if (str[]=='N' && mouse<root->size) mouse++;

         else if (str[]=='R') scanf("%d", &x), rotate(x);

         else if (str[]=='D') scanf("%d", &x), remove(x);

         else

         {

             scanf("%d", &x);

             do gets(str); while (!strlen(str));

             insert(str, x);

         }

     }

     return ;

 }

 inline void insert(char * s, int l)

 {

     treap::node * L, * M, * R;

     treap::split(root, mouse, L, R);

     M=treap::newtreap(s, l, inf);

     L=treap::merge(L, M);

     root=treap::merge(L, R);

 }

 inline void remove(int l)

 {

     treap::node * L, * M, * R;

     treap::split(root, mouse, L, R);

     treap::split(R, l, M, R);

     root=treap::merge(L, R);

 }

 inline void rotate(int l)

 {

     treap::node * L, * M, * R;

     treap::split(root, mouse, L, R);

     treap::split(R, l, M, R);

     M->rev^=;

     L=treap::merge(L, M);

     root=treap::merge(L, R);

 }

 inline char get()

 {

     treap::node * i=root;

     int k=mouse+;

     for ( ; ; )

     {

         i->pushdown();

         if (i->left->size+==k) return i->ch;

         if (i->left->size+<k)

         {

             k-=i->left->size+;

             i=i->right;

         }

         else

             i=i->left;

     }

 }