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

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

class TreapVector{
  private:

    struct Node{
        Node *ls, *rs;
        int val;
        int pri;
        int cnt;
        bool rev;
        Node(){
            ls=rs=NULL,
            val=0,
            cnt=0,
            rev=0,
            pri=rand()||(rand()<<31);
        }
    };

    Node *root;

    void push (Node *root){
        if (root&&root->rev){
            root->rev=0;
            swap(root->ls,root->rs);
            if(root->ls) root->ls->rev^=1;
            if(root->rs) root->rs->rev^=1;
    }
}

    int cnt(Node *root){
        return root?root->cnt:0;
    }

    void upd(Node *root){
        if(root) root->cnt=1+cnt(root->ls)+cnt(root->rs);
    }

    void join(Node *&root, Node *l, Node *r){
        push(l), push(r);
        if(!l||!r) root=l?l:r;
        else if(l->pri>r->pri){
            join(l->rs, l->rs, r);
            root=l;
        }
        else{
            join(r->ls, l, r->ls);
            root=r;
        }
        upd(root);
    }

    void split(Node *root, Node *&l, Node *&r, int poz){
        if(!root){
            l=r=NULL;
        }
        else if(cnt(root->ls)>=poz){
            push(root);
            split(root->ls, l, root->ls, poz);
            r=root;
        }
        else{
            push(root);
            split(root->rs, root->rs, r, poz-cnt(root->ls)-1);
            l=root;
        }
        upd(root);
    }

    void auxshow(Node *root){
        if(!root) return;
        push(root);
        auxshow(root->ls);
        fout<<root->val<<" ";
        auxshow(root->rs);
    }

    void insert(Node *&root, Node *a, int poz){
        push(root);
        Node *p1, *p2;
        split(root, p1, p2, poz-1);
        join(p1, p1, a);
        join(root, p1, p2);
    }

    void erase(Node *&root, int lp, int rp){
        Node *p1, *p2, *p3;
        split(root, p1, p2, lp);
        split(p2, p2, p3, rp-lp+1);
        join(root, p1, p3);
    }

    void reverse(Node *&root, int lp, int rp){
        Node *p1, *p2, *p3;
        split(root, p1, p2, lp);
        split(p2, p2, p3, rp-lp+1);
        p2->rev^=1;
        join(root, p1, p2);
        join(root, root, p3);
    }

    int get(Node *&root, int poz){
        if(!root) return -1;
        int nr=cnt(root->ls);
        if(nr==poz-1){
            return root->val;
        }
        if(nr>=poz){
            return get(root->ls, poz);
        }
        else{
            return get(root->rs, poz-nr-1);
        }
    }

  public:
    void add(int x, int poz){
        Node *a=new Node;
        a->val=x;
        insert(root, a, poz);
    }

    void show(){
        if(!root) return;
        push(root);
        auxshow(root->ls);
        fout<<root->val<<" ";
        auxshow(root->rs);
        fout<<"\n";
    }

    void del(int poz){
        erase(root, poz-1, poz-1);
    }

    void del(int i, int j){
        erase(root, i-1, j-1);
    }

    int get(int poz){
        return get(root, poz);
    }

    void reverse(int l, int r){
        reverse(root, l-1, r-1);
    }

};

TreapVector v;

int main()
{
    int n, trash;
    fin>>n>>trash;
    while(n--){
        char t;
        fin>>t;
        if(t=='I'){
            int k, e;
            fin>>k>>e;
            v.add(e, k);
        }
        else if(t=='A'){
            int k;
            fin>>k;
            fout<<v.get(k)<<"\n";
        }
        else if(t=='R'){
            int i, j;
            fin>>i>>j;
            v.reverse(i, j);
        }
        else{
            int i, j;
            fin>>i>>j;
            v.del(i, j);
        }
    }v.show();
    return 0;
}