#include <cstdio>
#include <algorithm>
#include <ctime>
#include <vector>

using namespace std;

class treap
{
    public:
        treap()
        {
            nil=new node(0,-1);
            nil->left=nil->right=nil;
            nil->nr=nil->rev=0;
            rad=nil;
        }
        void insert(int poz,int val)
        {
            rad=insert(rad,poz,val,rand());
        }
        void erase(int poz)
        {
            rad=erase(rad,poz);
        }
        int find(int poz)
        {
            return find(rad,poz);
        }
        void reverse(int st,int dr)
        {
            pairnode a=split(rad,st-1);
            pairnode b=split(a.right,dr-st+1);
            b.left->rev^=1;
            rad=merge(a.left,b.left);
            rad=merge(rad,b.right);
        }
        vector<int> getvector()
        {
            q.clear();
            dfs(rad);
            return q;
        }
    private:
        struct node
        {
            node *left,*right;
            int val,priority,nr;
            char rev;
            node(int val1,int priority1) {val=val1;priority=priority1;}
            node(node *left1,node *right1,int val1,int priority1,char rev1)
            {
                left=left1;right=right1;
                val=val1;priority=priority1;rev=rev1;
                update(1);
            }
            void update(int tip)
            {
                if(tip) nr=left->nr+right->nr+1;
                if(rev)
                {
                    rev=0;
                    swap(left,right);
                    left->rev^=1;
                    right->rev^=1;
                }
            }
        };
        node *rad,*nil;
        struct pairnode
        {
            node *left,*right;
            pairnode(node *left1,node *right1) {left=left1;right=right1;}
        };
        vector<int> q;

        node *insert(node *nod,int poz,int val,int priority)
        {
            nod->update(0);
            if(nod->priority<priority)
            {
                pairnode a=split(nod,poz);
                return new node(a.left,a.right,val,priority,0);
            }
            if(poz<=nod->left->nr) nod->left=insert(nod->left,poz,val,priority);
            else nod->right=insert(nod->right,poz-nod->left->nr-1,val,priority);
            nod->update(1);
            return nod;
        }
        pairnode split(node *nod,int poz)
        {
            nod->update(0);
            if(nod==nil) return pairnode(nil,nil);
            if(poz<=nod->left->nr)
            {
                pairnode a=split(nod->left,poz);
                nod->left=a.right;
                nod->update(1);
                return pairnode(a.left,nod);
            }
            else
            {
                pairnode a=split(nod->right,poz-nod->left->nr-1);
                nod->right=a.left;
                nod->update(1);
                return pairnode(nod,a.right);
            }
        }
        node *erase(node *nod,int poz)
        {
            nod->update(0);
            if(poz==nod->left->nr+1)
            {
                node *a=merge(nod->left,nod->right);
                delete nod;
                return a;
            }
            if(poz<=nod->left->nr) nod->left=erase(nod->left,poz);
            else nod->right=erase(nod->right,poz-nod->left->nr-1);
            nod->update(1);
            return nod;
        }
        node *merge(node *left,node *right)
        {
            left->update(0);
            right->update(0);
            if(left==nil && right==nil) return nil;
            if(left->priority>right->priority)
            {
                left->right=merge(left->right,right);
                left->update(1);
                return left;
            }
            else
            {
                right->left=merge(left,right->left);
                right->update(1);
                return right;
            }
        }
        int find(node *nod,int poz)
        {
            nod->update(0);
            if(poz==nod->left->nr+1) return nod->val;
            if(poz<=nod->left->nr) return find(nod->left,poz);
            else return find(nod->right,poz-nod->left->nr-1);
        }
        void dfs(node *nod)
        {
            if(nod==nil) return;
            dfs(nod->left);
            q.push_back(nod->val);
            dfs(nod->right);
        }
};

int main()
{
    freopen("secv8.in", "r", stdin);
    freopen("secv8.out", "w", stdout);
    srand(time(0));
    int n,x,y;
    char tip;
    treap v;
    scanf("%d%d",&n,&tip);
    for(int i=1;i<=n;i++)
    {
        scanf("\n%c",&tip);
        if(tip=='I')
        {
            scanf("%d%d",&x,&y);
            v.insert(x-1,y);
        }
        else if(tip=='A')
        {
            scanf("%d",&x);
            printf("%d\n",v.find(x));
        }
        else if(tip=='R')
        {
            scanf("%d%d",&x,&y);
            v.reverse(x,y);
        }
        else if(tip=='D')
        {
            scanf("%d%d",&x,&y);
            for(int j=x;j<=y;j++) v.erase(x);
        }
    }
    vector<int> sol=v.getvector();
    for(vector<int>::iterator it=sol.begin();it!=sol.end();it++) printf("%d ",*it);
    return 0;
}