#include <bits/stdc++.h>

using namespace std;

#define fi first
#define se second
#define VI vector<int>
#define PII pair<int,int>
#define PDD pair<double,double>
#define ll long long
#define lf double
#define pb push_back
#define For(i, j, n)for(int i = j;i <= n;i++)
#define iFor(i, j, n)for(int i = n;i >= j;i--)
#define R scanf
#define S scanf
#define P printf
#define fin stdin
#define fout stdout

#define DBG 1

struct nod  {
    int key, size;
    int prio;
    bool flip;
    nod *l, *r;
} nil {};

inline void prop(nod *n)  {
    if(n -> flip)  {
        n -> flip = 0;
        swap(n -> l, n -> r);
        n -> l -> flip ^= 1;
        n -> r -> flip ^= 1;
    }
}

inline void actual(nod *n)  {
    n -> size = n -> l -> size + n -> r -> size + 1;
}

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);
        actual(l);
        return l;
    }
    else  {
        r -> l = join(l, r -> l);
        actual(r);
        return r;
    }
}

pair <nod*, nod*> split(nod *n, int poz)  {
    if(n == &nil)
        return {&nil, &nil};
    prop(n);
    if(n -> l -> size == poz)  {
        nod *aux = n -> l;
        n -> l = &nil;
        actual(n);
        return {aux, n};
    }
    else if(n -> l -> size < poz)  {
        pair <nod*, nod*> aux = split(n -> r, poz - n -> l -> size - 1);
        n -> r = aux.fi;
        aux.fi = n;
        actual(n);
        return aux;
    }
    else  {
        pair <nod*, nod*> aux = split(n -> l, poz);
        n -> l = aux.se;
        aux.se = n;
        actual(n);
        return aux;
    }
}

nod *insert(nod *n, int poz, int key)  {
    pair <nod*, nod*> p = split(n, poz);
    return join(join(p.fi, new nod {key, 1, rand(), 0, &nil, &nil}), p.se);
}

int see(nod *n, int poz)  {
    prop(n);
    if(n -> l -> size == poz)
        return n -> key;
    else if(n -> l -> size > poz)
        return see(n -> l, poz);
    else return see(n -> r, poz - n -> l -> size - 1);
}

tuple <nod*, nod*, nod*> triple_split(nod *n, int poz1, int poz2)  {
    pair <nod*, nod*> aux = split(n, poz2), aux1 = split(aux.fi, poz1);
    return make_tuple(aux1.fi, aux1.se, aux.se);
}

nod *reverse(nod *n, int c1, int c2)  {
    tuple <nod*, nod*, nod*> aux = triple_split(n, c1, c2);
    get <1> (aux) -> flip ^= 1;
    return join(join(get <0> (aux), get <1> (aux)), get <2> (aux));
}

nod *erase(nod *n, int c1, int c2)  {
    tuple <nod*, nod*, nod*> aux = triple_split(n, c1, c2);
    return join(get <0> (aux), get <2> (aux));
}

void dfs(nod *n)  {
    if(n == &nil)
        return;
    prop(n);
    dfs(n -> l);
    printf("%d ", n -> key);
    dfs(n -> r);
}

int main()  {
    srand(time(0));
	if(DBG)  {
		freopen("secv8.in", "r", stdin);
		freopen("secv8.out", "w", stdout);
	}
    int op, III;
    R("%d%d", &op, &III);
    getchar();
    nod * rad = &nil;
    while(op--)  {
        char c;
        c = getchar();
        if(c == 'I')  {
            int poz, key;
            scanf("%d%d", &poz, &key);
            getchar();
            rad = insert(rad, poz - 1, key);
        }
        else if(c == 'A')  {
            int poz;
            scanf("%d", &poz);
            getchar();
            printf("%d\n", see(rad, poz - 1));
        }
        else if(c == 'R')  {
            int c1, c2;
            scanf("%d%d", &c1, &c2);
            getchar();
            rad = reverse(rad, c1 - 1, c2);
        }
        else  {
            int c1, c2;
            scanf("%d%d", &c1, &c2);
            getchar();
            rad = erase(rad, c1 - 1, c2);
        }
    }
    dfs(rad);
	return 0;
}