//HighFlow
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <fstream>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
#define fcat(c) while (c!='\n') fscanf(f,"%c",&c)
#define cat(c) while (c!='\n') scanf("%c",&c)
#define For(i,st,dr,k) for (int i=(st);i<=(dr);i+=(k))
#define ll (long long)
#define kfl(i,j) (a[(i)][(j)].c-a[(i)][(j)].f)
 
using namespace std;
FILE *f,*g;
 
 
struct T {
    int pr, size,val;
    bool inv;
    T *left, *right;
    T() {}
    T(int pr, int size, int val,bool inv, T* left, T* right) {
        this->pr = pr;
        this->size = size;
        this->val = val;
        this->inv = inv;
        this->left = left, this->right = right;
    }
} *R, *nil, *R1,*R2,*R3,*Rax; // nil indica un nod 'gol'
 
void init(T* &R) {
    srand(unsigned(time(0)));
    R = nil = new T(0,0,0,false, NULL, NULL);
}
 
void fa_inv(T* &n)
{
    if (n->inv==false) return ;
    n->inv=false;
    T* ax= n->left;
    n->left=n->right;
    n->right=ax;
    if (n->left!=nil)n->left->inv^=1;
    if (n->right!=nil) n->right->inv^=1;
}
void fa_size(T* &n)
{
    n->size=n->left->size+n->right->size+1;
}
 
 
void rotleft(T* &n) {
    T *t = n->left;
    n->left = t->right, t->right = n;
    n = t;
 
    fa_size(n->right);
    fa_size(n);
}
 
void rotright(T* &n)
{
 
    T *t= n->right;
    n->right=t->left; t->left = n;
    n=t;
 
    fa_size(n->left);
    fa_size(n);
}
 
 
 
void balance(T* &n) {
    fa_inv(n);
 
    if (n->left->pr > n->pr)
    {
        fa_inv(n->left);
        rotleft(n);
    }
    else if (n->right->pr > n->pr)
    {
        fa_inv(n->right);
        rotright(n);
    }
}
 
 
 
 
void insert(T* &n,int sum, int val, int pri)
{
    if (n==nil)
    {
        n=new T(pri, 1, val, false, nil,nil);
        return ;
    }
 
    fa_inv(n);
    if (sum<=n->left->size+1)
        insert(n->left,sum, val, pri);
    else
        insert(n->right,sum-n->left->size-1, val , pri);
    fa_size(n);
    balance(n);
}
 
void erase(T* &n ,int sum)
{
    if (n==nil) return ;
 
    fa_inv(n);
 
    if (sum<n->left->size+1)
    {
        erase(n->left,sum);
        fa_size(n);
    }
    else
        if (sum>n->left->size+1)
        {
            erase(n->right, sum-n->left->size-1);
            fa_size(n);
        }
                else
                {
                    if (n->left==nil && n->right==nil)
                        delete n, n=nil;
                    else
                    {
                        if (n->left->pr  > n->right->pr)
                        {
                            fa_inv(n->left);
                            rotleft(n);
                            erase(n->right,n->right->left->size+1);
                            fa_size(n);
                        }
                        else
                        {
                            fa_inv(n->right);
                            rotright(n);
                            erase(n->left, n->left->left->size+1);
                            fa_size(n);
                        }
 
                    }
                }
}
 
int acces(T* &n,int sum)
{
    fa_inv(n);
    if (1+n->left->size==sum) return n->val;
    if (1+n->left->size>sum) return (acces(n->left,sum));
    else return(acces(n->right, sum-n->left->size-1));
}
 
void split(T* &R, T* &Ts, T* &Tg,int w) {
    insert(R, w+1, 0,  1000100);
    Ts = R->left, Tg = R->right;
    delete R, R = nil;
}
 
void join(T* &R, T* Ts, T* Tg) {
    R = new T(0,1+Ts->size+Tg->size,0, 0, Ts, Tg);
    erase(R, 1+Ts->size);
}
 
void final(T* &R)
{
    fa_inv(R);
    if (R==nil) return ;
    final(R->left);
    fprintf(g,"%d ",R->val);
    final(R->right);
}
 
int t,q,x,y;
char c;
int nimic;
 
int main()
{
    f=fopen("secv8.in","r");
    g=fopen("secv8.out","w");
 
    init(R);
    fscanf(f,"%d%d",&t,&nimic);
 
    for (q=1;q<=t;q++)
    {
        fscanf(f,"%c",&c);
        fcat(c);
        fscanf(f,"%c",&c);
        if (c=='I')
        {
            fscanf(f,"%d%d",&y,&x);
            insert(R,y,x,1+rand()%100000);
            continue;
        }
        if (c=='A')
        {
            fscanf(f,"%d",&x);
            fprintf(g,"%d\n",acces(R,x));
            continue;
        }
        if (c=='R')
        {
            fscanf(f,"%d%d",&x,&y);
            split(R,R1,Rax,x-1);
            split(Rax,R2,R3,y-x+1);
            R2->inv^=1;
 
            join(Rax,R2,R3);
            join(R,R1,Rax);
            continue;
        }
        if (c=='D')
        {
            fscanf(f,"%d%d",&x,&y);
            split(R,R1,Rax,x-1);
            split(Rax,R2,R3,y-x+1);
 
            join(R,R1,R3);
            continue;
        }
    }
 
    final(R);
 
    return 0;
}