#include <bits/stdc++.h>
using namespace std;
 
struct nod{
    int key, size, prio, flip;
    nod *l, *r; } nil {};
 
void reset(nod *n){
    n->size = n->l->size + n->r->size + 1; }
 
void prop(nod *n){
    if(n->flip){
        n->flip = 0;
        swap(n->l, n->r);
        n->l->flip ^= 1;
        n->r->flip ^= 1; } }
 
void dfs(nod *n, ostream& g){
    if(n == &nil) return;
    prop(n);
    dfs(n->l, g);
    g << n->key << ' ';
    dfs(n->r, g); }
 
nod *join(nod *l, nod *r){
    if(l == &nil) return r;
    if(r == &nil) return l;
    prop(l), prop(r);
    if(l->prio >= r->prio){
        l->r = join(l->r, r);
        reset(l);
        return l; }
    else{
        r->l = join(l, r->l);
        reset(r);
        return r; } }
 
pair<nod*, nod*> split(nod *n, const int poz){
    if(n == &nil) return make_pair(&nil, &nil);
    prop(n);
    if(n->l->size == poz){
        nod *aux = n->l;
        n->l = &nil;
        reset(n);
        return make_pair(aux, n); }
    else if(n->l->size < poz){
        pair<nod*, nod*> tmp = split(n->r, poz - n->l->size - 1);
        n->r = tmp.first;
        tmp.first = n;
        reset(n);
        return tmp; }
    else{
        pair<nod*, nod*> tmp = split(n->l, poz);
        n->l = tmp.second;
        tmp.second = n;
        reset(n);
        return tmp; } }
 
int access(nod *n, const int poz){
    prop(n);
    if(n->l->size == poz) return n->key;
    else if(n->l->size > poz) return access(n->l, poz);
    else return access(n->r, poz - n->l->size - 1); }
 
nod *insert(nod *n, const int poz, const int key){
    pair<nod*, nod*> p = split(n, poz);
    return join(join(p.first, new nod { key, 1, rand(), 0, &nil, &nil }), p.second); }
 
tuple<nod*, nod*, nod*> three_way_split(nod *n, const int p1, const int p2){
    pair<nod*, nod*> p = split(n, p2), _p = split(p.first, p1);
    return make_tuple(_p.first, _p.second, p.second); }
 
nod *erase(nod *n, const int p1, const int p2){
    auto p = three_way_split(n, p1, p2);
    return join(get<0>(p), get<2>(p)); }
 
nod *reverse(nod *n, const int p1, const int p2){
    auto p = three_way_split(n, p1, p2);
    get<1>(p)->flip ^= 1;
    return join(join(get<0>(p), get<1>(p)), get<2>(p)); }
 
int main(){
    srand(time(nullptr));
    ifstream f("secv8.in");
    ofstream g("secv8.out");
    int n, xxx;
 
    f >> n >> xxx;
 
    nod *rad = &nil;
 
    for(int poz, key, p1, p2; n--; ){
        char ch;
        f >> ch;
        if(ch == 'I'){
            f >> poz >> key;
            rad = insert(rad, poz-1, key); }
        else if(ch == 'A'){
            f >> poz;
            g << access(rad, poz-1) << '\n'; }
        else if(ch == 'R'){
            f >> p1 >> p2;
            rad = reverse(rad, p1-1, p2); }
        else{
            f >> p1 >> p2;
            rad = erase(rad, p1-1, p2); } }
 
    dfs(rad, g);
 
    return 0; }