#include <bits/stdc++.h>

using namespace std;

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

const int mod = 1000000000;

struct treap
{
    int x , v , d , p;
    treap *tol , *tor;
    bool ok;

    treap(int ad , int ax , int ap , treap *atol , treap* ator)
    {
        d = ad;
        x = ax;
        p = ap;
        ok = 0;
        tol = atol;
        tor = ator;
    }
};

treap *r , *nth , *lr , *rr;
int q , ax , ap , i , j , k;
char t;

void getd(treap *(&r))
{
    (r -> d) = (r -> tol -> d) + (r -> tor -> d) + 1;
}

void getok(treap *(&r))
{
    if (r -> ok == 1)
    {
        swap(r -> tor , r -> tol);

        r -> tor -> ok ^= 1;
        r -> tol -> ok ^= 1;
        r -> ok ^= 1;
    }
}

void rol(treap *(&r))
{
    treap *ar;

    ar = r -> tol;
    r -> tol = ar -> tor;
    ar -> tor = r;
    r = ar;

    getd(r -> tor);
    getd(r);
}

void ror(treap *(&r))
{
    treap *ar;

    ar = r -> tor;
    r -> tor = ar -> tol;
    ar -> tol = r;
    r = ar;

    getd(r -> tol);
    getd(r);
}

void balance(treap *(&r))
{
    if (r -> tol -> p > r -> p)
    {
        getok(r);
        getok(r -> tol);
        rol(r);
    }

    if (r -> tor -> p > r -> p)
    {
        getok(r);
        getok(r -> tor);
        ror(r);
    }
}

void add(treap *(&r) , int k , int ax , int ap)
{
    if (r == nth)
    {
        r = new treap(1 , ax , ap , nth , nth);
        return ;
    }

    getok(r);

    if (1 + r -> tol -> d >= k) add(r -> tol , k , ax , ap);
    else add(r -> tor , k - (1 + r -> tol -> d) , ax , ap);

    getd(r);
    balance(r);
}

void erase(treap *(&r) , int k)
{
    getok(r);

    if (1 + r -> tol -> d > k)
    {
        erase(r -> tol , k);
        getd(r);
        return ;
    }

    if (1 + r -> tol -> d < k)
    {
        erase(r -> tor , k - (1 + r -> tol -> d));
        getd(r);
        return ;
    }

    if (r -> tol == nth && r -> tor == nth)
    {
        r = nth;
        return ;
    }

    if (r -> tol -> p > r -> tor -> p)
    {
        getok(r -> tol);
        rol(r);

        erase(r -> tor , 1 + r -> tor -> tol -> d);
        getd(r);
    }
    else
    {
        getok(r -> tor);
        ror(r);
        erase(r -> tol , 1 + r -> tol -> tol -> d);
        getd(r);
    }
}

int show(treap *r , int k)
{
    getok(r);

    if (1 + r -> tol -> d == k) return r -> x;
    if (1 + r -> tol -> d > k) return show(r -> tol , k);
    else return show(r -> tor , k - (r -> tol -> d + 1));
}

void split(treap *r , int k , treap *(&rl) , treap *(&rr))
{
    add(r , k + 1 , 0 , mod);
    rl = r -> tol;
    rr = r -> tor;
    delete r;
}

void join(treap *(&r) , treap *rl , treap *rr)
{
    if (rl == nth)
    {
        r = rr;
        return ;
    }

    if (rr == nth)
    {
        r = rl;
        return ;
    }

    getok(rl) , getok(rr);

    r = new treap(1 + rl -> d + rr -> d , 0 , 0 , rl , rr);
    erase(r , 1 + rl -> d);
}

void df(treap *r)
{
    if (r == nth) return;

    getok(r);
    df(r -> tol);
    fout << r -> x << " ";
    df(r -> tor);
}

int main()
{

r = new treap(0 , 0 , 0 , 0 , 0);
nth = r;

for (fin >> q >> t ; q ; --q)
{
    fin >> t;

    if (t == 'I')
    {
        fin >> k >> ax;
        ap = rand() % mod + 1;
        add(r , k , ax , ap);
    }

    if (t == 'A')
    {
        fin >> k;
        fout << show(r , k) << '\n';
    }

    if (t == 'R')
    {
        fin >> i >> j;

        split(r , i - 1 , lr , r);
        split(r , j - i + 1 , r , rr);

        r -> ok ^= 1;

        join(r , lr , r);
        join(r , r , rr);
    }

    if (t == 'D')
    {
        fin >> i >> j;

        split(r , i - 1 , lr , r);
        split(r , j - i + 1 , r , rr);

        join(r , lr , rr);
    }
}

df(r);

return 0;
}