#include <bits/stdc++.h>
#define INF 2000000000
using namespace std;
ifstream fin ("secv8.in");
ofstream fout ("secv8.out");

int q,x,y,poz,val;
char ch;

struct treap{
    int val,nr,lazy,priority;
    treap *left, *right;

    treap (int val, int nr, int lazy, int priority, treap *left, treap *right){
        this->val = val;
        this->nr = nr;
        this->lazy = lazy;
        this->priority = priority;
        this->left = left;
        this->right = right;
    }
};

treap *rad, *nil;

treap* update (treap *rad){
    if (rad == nil)
        rad->nr = 0;
    else {

        rad->nr = rad->left->nr + rad->right->nr + 1;

        if (rad->lazy){

            if (rad->left != nil)
                rad->left->lazy = 1 - rad->left->lazy;
            if (rad->right != nil)
                rad->right->lazy = 1 - rad->right->lazy;

            swap (rad->left,rad->right);

            rad->lazy = 0;
        }
    }

    return rad;
}

pair <treap*, treap*> split (treap *rad, int poz){
    rad = update (rad);
    pair <treap*, treap*> ans;

    if (rad == nil)
        return make_pair (nil,nil);

    if (rad->left->nr + 1 > poz){
        ans = split (rad->left,poz);
        rad->left = ans.second;
        ans.second = rad;
    } else {
        ans = split (rad->right,poz - rad->left->nr - 1);
        rad->right = ans.first;
        ans.first = rad;
    }

    rad = update (rad);
    return ans;
}

treap* join (treap *rad1, treap *rad2){
    if (rad1 == nil)
        return rad2;
    if (rad2 == nil)
        return rad1;

    rad1 = update (rad1), rad2 = update (rad2);
    if (rad1->priority <= rad2->priority){

        rad2->left = join (rad1,rad2->left);
        rad2 = update (rad2);
        return rad2;

    }  else {
        rad1->right = join (rad1->right,rad2);
        rad1 = update (rad1);
        return rad1;
    }

    return nil;
}

treap* _insert (treap *rad, int poz, int val, int priority){

    if (rad == nil){
        rad = new treap (val,1,0,priority,nil,nil);
        rad = update (rad);
        return rad;
    }

    pair<treap*, treap*> aux = split (rad,poz-1);
    rad = new treap (val,1,0,priority,aux.first,aux.second);
    rad = update(rad);
    return rad;
}

int get_elem (treap *&rad, int poz){

    rad = update (rad);
    if (rad->left->nr + 1 == poz)
        return rad->val;

    else {
        if (rad->left->nr + 1 > poz)
            return get_elem (rad->left,poz);
        else return get_elem (rad->right,poz-rad->left->nr-1);
    }
}


treap* _reverse (treap *rad, int x, int y){

    pair <treap*,treap*> aux = split (rad,y);
    pair <treap*,treap*> aux2 = split (aux.first,x-1);

    aux2.second->lazy = 1;

    aux.first = join (aux2.first,aux2.second);
    rad = join (aux.first,aux.second);
    //rad = update (rad);

    return rad;
}

treap* _delete (treap *rad, int x, int y){
    pair <treap*,treap*> aux = split (rad,y);
    pair <treap*,treap*> aux2 = split (aux.first,x-1);

    rad = join (aux2.first, aux.second);
    rad = update (rad);
    return rad;
}

void dfs (treap *&rad){
    rad = update (rad);
    if (rad == nil)
        return;
    dfs (rad->left);
    fout<<rad->val<<" ";
    dfs (rad->right);
}

int get_random(){
    return rand()%(INF-1) + 1;
}

int main (){

    //srand (time(0));

    rad = nil = new treap (0,0,0,0,NULL,NULL);

    fin>>q>>x;

    for (;q--;){

        fin>>ch;
        if (ch == 'I'){
            fin>>poz>>val;
            rad = _insert (rad,poz,val,get_random());
            //dfs (rad);
            //cout<<"\n";
            continue;
        }

        if (ch == 'A'){
            fin>>x;
            fout<<get_elem(rad,x)<<"\n";

            continue;
        }

        if (ch == 'R'){
            fin>>x>>y;
            rad = _reverse (rad,x,y);

            continue;
        }

        if (ch == 'D'){
            fin>>x>>y;
            rad = _delete (rad,x,y);
        }
    }

    dfs (rad);

    return 0;
}