#include <fstream>
#include <ctime>
#include <random>
#define dim 200000
using namespace std;
ifstream fin ("secv8.in");
ofstream fout ("secv8.out");
mt19937 rnd (time (0));
struct elem
{
    int val,pr,l,r,cnt;
    bool lazy;
};
struct treap
{
    elem v[dim+1];
    int nr,rt;
    int val;
    treap ()
    {
        nr=rt=0;
    }
    void propagate (int node)
    {
        if (node&&v[node].lazy)
        {
            if (v[node].l)
                v[v[node].l].lazy^=1;
            if (v[node].r)
                v[v[node].r].lazy^=1;
            swap (v[node].l,v[node].r);
            v[node].lazy=0;
        }
    }
    void update_cnt (int node)
    {
        v[node].cnt=1+v[v[node].l].cnt+v[v[node].r].cnt;
    }
    int get_kth (int node,int nodeval)
    {
        propagate (node);
        int nr=nodeval+v[v[node].l].cnt+1;
        if (nr==val)
            return node;
        if (nr<val)
            return get_kth (v[node].r,nr);
        return get_kth (v[node].l,nodeval);
    }
    void split (int node,int &l,int &r,int nodeval)
    {
        if (node==0)
            l=r=0;
        else
        {
            propagate (node);
            if (nodeval+v[v[node].l].cnt+1<=val)
            {
                split (v[node].r,v[node].r,r,nodeval+v[v[node].l].cnt+1);
                l=node;
                update_cnt (l);
            }
            else
            {
                split (v[node].l,l,v[node].l,nodeval);
                r=node;
                update_cnt (r);
            }
        }
    }
    void merge (int &node,int a,int b)
    {
        if (a==0)
            node=b;
        else if (b==0)
            node=a;
        else
        {
            if (v[a].pr>=v[b].pr)
            {
                propagate (a);
                merge (v[a].r,v[a].r,b);
                node=a;
            }
            else
            {
                propagate (b);
                merge (v[b].l,a,v[b].l);
                node=b;
            }
        }
        update_cnt (node);
    }
    void dfs (int node)
    {
        if (node>0)
        {
            propagate (node);
            dfs (v[node].l);
            fout<<v[node].val<<" ";
            dfs (v[node].r);
        }
    }
    void make_dfs ()
    {
        dfs (rt);
    }
    int make_get_kth (int k)
    {
        val=k;
        return get_kth (rt,0);
    }
    void make_insert (int k,int x,int pr)
    {
        int a=0,b=0;
        v[++nr]= {x,pr,0,0,1,0};
        val=k-1,split (rt,a,b,0);
        merge (rt,a,nr);
        merge (rt,rt,b);
    }
    void make_rev (int le,int ri)
    {
        int a=0,b=0,c=0;
        val=le-1,split (rt,a,b,0);
        val=ri-(le-1),split (b,b,c,0);
        v[b].lazy^=1;
        merge (rt,a,b);
        merge (rt,rt,c);
    }
    void make_del (int le,int ri)
    {
        int a=0,b=0,c=0;
        val=le-1,split (rt,a,b,0);
        val=ri-(le-1),split (b,b,c,0);
        merge (rt,a,c);
    }
};
treap trp;
int main ()
{
    int n,l,r,k,val,ok;
    char ch;
    fin>>n>>ok;
    while (fin>>ch)
    {
        if (ch=='I')
        {
            fin>>k>>val;
            trp.make_insert (k,val,rnd ());
        }
        else if (ch=='A')
        {
            fin>>k;
            fout<<trp.make_get_kth (k)<<"\n";
        }
        else if (ch=='R')
        {
            fin>>l>>r;
            trp.make_rev (l,r);
        }
        else
        {
            fin>>l>>r;
            trp.make_del (l,r);
        }
    }
    trp.make_dfs ();
    return 0;
}