#include <bits/stdc++.h>
#define paa pair <Arbore, Arbore>
using namespace std;

typedef struct Nod * Arbore;

struct Nod
{
    int g, prio, val;
    Arbore st, dr;
    bool rev;
    Nod(Arbore x = 0, int priority = 0, int _val = 0) : st(x), dr(x), g(1), rev(false), prio(priority), val(_val) { }
};

Arbore NIL;
ofstream out("secv8.out");

Arbore join(Arbore a, Arbore b);
paa split(Arbore a, int poz);
Arbore join(Arbore a, Arbore b, Arbore c);
void reset(Arbore x);
void propagate(Arbore x);
Arbore add(Arbore x, int val, int poz);
Arbore scoate(Arbore x, int a, int b);
int access(Arbore x, int poz);
Arbore invers(Arbore x, int a, int b);
void print(Arbore k);

int main()
{
    srand(time(NULL));
    ifstream in("secv8.in");
    NIL = new Nod();

    NIL->st = NIL->dr = NIL;
    NIL->g = NIL->prio = NIL->val = 0;
    int n, a, b;
    in >> n >> a;

    Arbore k = NIL;

    while (n--) {
        char c;
        in >> c;
        if (c == 'I') {
            in >> a >> b;
            k = add(k, b, a);
        }
        else if (c == 'A') {
            in >> a;
            out << access(k, a) << '\n';
        }
        else if (c == 'R') {
            in >> a >> b;
            k = invers(k, a, b);
        }
        else if (c == 'D') {
            in >> a >> b;
            k = scoate(k, a, b);
        }
    }
    print(k);

    return 0;
}

void print(Arbore k)
{
    if (k == NIL)
        return;
    print(k->st);
    out << k->val << ' ';
    print(k->dr);
}

Arbore invers(Arbore x, int a, int b)
{
    paa q(split(x, a));
    paa z(split(q.second, b + 1));
    z.first->rev = 1;
    return join(q.first, z.first, z.second);
}

int access(Arbore x, int poz)
{
    propagate(x);
    if (poz == x->st->g + 1)
        return x->val;
    if (poz <= x->st->g)
        return access(x->st, poz);
    return access(x->dr, poz - 1 - x->st->g);
}

Arbore scoate(Arbore x, int a, int b)
{
    paa q(split(x, b + 1));
    paa z(split(q.first, a));
    delete z.second;
    return join(z.first, q.second);
}

Arbore add(Arbore x, int val, int poz)
{
    paa q(split(x, poz));
    return join(q.first, new Nod(NIL, rand(), val), q.second);
}

void propagate(Arbore x)
{
    if (x->rev) {
        x->rev = 0;
        swap(x->st, x->dr);
        x->st->rev ^= 1;
        x->dr->rev ^= 1;
    }
}

void reset(Arbore x)
{
    if (x != NIL)
        x->g = x->st->g + x->dr->g + 1;
}

paa split(Arbore a, int poz)
{
    if (a == NIL)
        return { NIL, NIL };

    propagate(a);

    if (poz == a->st->g + 1) {
        Arbore x(a->st);
        a->st = NIL;
        reset(a);
        return { x, a };
    }
    if (poz <= a->st->g) {
        paa x(split(a->st, poz));
        a->st = x.second;
        reset(a);
        return { x.first, a };
    }
    /// else
    poz -= a->st->g + 1;
    paa x(split(a->dr, poz));
    a->dr = x.first;
    reset(a);
    return { a, x.second };
}

Arbore join(Arbore a, Arbore b, Arbore c)
{
    return join(join(a, b), c);
}


Arbore join(Arbore a, Arbore b)
{
    if (a == NIL)
        return b;
    if (b == NIL)
        return a;

    propagate(a);
    propagate(b);

    if (a->prio >= b->prio) {
        a->dr = join(a->dr, b);
        reset(a);
        return a;
    }
    /// else
    b->st = join(a, b->st);
    reset(b);
    return b;
}