#include <bits/stdc++.h>

using namespace std;

ifstream f("secv8.in");
ofstream g("secv8.out");

char parse[1<<18],*now;

void verify()
{
    if(*now==0)
    {
        f.get(parse,1<<18,'\0');
        now=parse;
    }
    return ;
}
int get1()
{
    while(*now<'0'||*now>'9')
    {
        ++now;
        verify();
    }
    int number=0;
    while(*now>='0'&&*now<='9')
    {
        number=number*10+(*now-'0');
        ++now;
        verify();
    }
    return number;
}
char get2()
{
    while(*now<'A'||*now>'Z')
    {
        ++now;
        verify();
    }
    char ret=*now;
    ++now;verify();
    return ret;

}

namespace Treap
{
struct Node
{
    Node *l=0,*r=0;
    int x=0;
    int y=0;
    int sz=0;
    int rev=0;
    Node(int _x=0): x(_x), y(rand()), rev(1), sz(1) {}
    void recalc();
};
int cnt(Node *t)
{
    if(!t)
        return 0;
    return t->sz;
}
void Node::recalc()
{
    sz=cnt(l)+cnt(r)+1;
    if(rev)
    {
        rev=0;
        swap(l,r);
        if(l)
            l->rev^=1;
        if(r)
            r->rev^=1;
    }
}
pair<Node*,Node*> split(Node *t,int k)
{
    if(!t)
        return {};

    t->recalc();
    if(cnt(t->l)>=k)
    {
        auto pa=split(t->l,k);
        t->l=pa.second;
        t->recalc();
        return {pa.first,t};
    }
    else
    {
        auto pa=split(t->r,k-cnt(t->l)-1);
        t->r=pa.first;
        t->recalc();
        return {t,pa.second};
    }

    return {};
}
Node* join(Node* l,Node* r)
{
    if(!l)
        return r;
    if(!r)
        return l;

    l->recalc();
    r->recalc();

    if(l->y > r->y)
    {
        l->r=join(l->r,r);
        l->recalc();
        return l;
    }
    else
    {
        r->l=join(l,r->l);
        r->recalc();
        return r;
    }
}
int acces(Node* t,int k)
{
    if(!t)
        return -1;
    t->recalc();
    if(cnt(t->l)+1==k)
        return t->x;
    if(cnt(t->l)>=k)
        return acces(t->l,k);
    return acces(t->r,k-cnt(t->l)-1);
}
Node* insert(Node* t,int k,int e)
{
    auto pa=split(t,k-1);
    return join(pa.first,join(new Node(e),pa.second));
}
Node* reverse(Node* t,int i,int j)
{
    auto pa=split(t,i-1);
    auto u =split(pa.second,j-i+1);
    u.first->rev^=1;
    return join(pa.first, join(u.first, u.second));
}
Node* erase(Node* t,int i,int j)
{
    auto pa=split(t,i-1);
    auto u =split(pa.second,j-i+1);
    return join(pa.first,u.second);
}
void output(Node* t)
{
    if(!t)
        return ;
    t->recalc();
    output(t->l);
    g<<(t->x)<<' ';
    output(t->r);
    return ;
}
}

int main()
{
    now=parse;
    verify();
    srand(time(nullptr));
    Treap::Node *root=0;
    int n,k,e;
    char c;
//    f>>n>>c;
    n=get1();
    int aux=get1();
    for(int i=1; i<=n; i++)
    {
//        f>>c;
        c=get2();
        if(c=='I')
        {
//            f>>k>>e;
            k=get1();
            e=get1();
            root=Treap::insert(root,k,e);
        }
        if(c=='A')
        {
//            f>>k;
            k=get1();
            g<<Treap::acces(root,k)<<'\n';
        }
        if(c=='R')
        {
            int a,b;
//            f>>a>>b;
            a=get1(),b=get1();
            root=Treap::reverse(root,a,b);
        }
        if(c=='D')
        {
            int a,b;
//            f>>a>>b;
            a=get1(),b=get1();
            root=Treap::erase(root,a,b);
        }
    }
    Treap::output(root);
    return 0;
}