using namespace std;

#include <set>
#include <map>
#include <list>
#include <deque>
#include <stack>
#include <queue>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <utility>
#include <iomanip>
#include <cstring>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>

#define pb push_back
#define size(V) ((int)(V.size()))
#define f first
#define s second
#define II inline
#define ll long long
#define db double
#define FORit(it, x) for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); ++it)
#define REP(i, N) for (int i = 0; i < (int)(N); ++i)
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define all(v) v.begin() , v.end()
#define CC(v) memset((v),0,sizeof((v)))
#define CP(v,w) memcpy((v),(w),sizeof((w)))
#define mp make_pair
#define oo 1<<30

#define IN "secv8.in"
#define OUT "secv8.out"

typedef vector<int> VI;
typedef pair<int,int> pi;
typedef vector<string> VS;
template<class T> string toString(T n) {ostringstream ost;ost<<n;ost.flush();return ost.str();}
typedef vector<string> VS;

struct treap
{
    int key,pri,nr;
    bool rev;
	treap *left,*right;
	
	treap() {} treap(int key,int pri, int nr,bool rev,treap* left, treap* right)
	{
		this->key = key;
		this->pri = pri;
		this->nr = nr;
		this->rev = rev;
		this->left = left, this->right = right;
	}
};

treap *rez,*nil,*R = nil;

int N,K,Ifreverse;
char buffer[1<<23];

II void read(int &aux)
{
	aux = 0;
	for(;buffer[K] < '0' || buffer[K] > '9';++K);
	for(;buffer[K] >= '0' && buffer[K] <= '9';++K)
		aux = aux * 10 + buffer[K] - '0';
}

II void read(char &aux)
{
	for(;buffer[K] < 'A' || buffer[K] > 'Z';++K);
	aux = buffer[K++];
}

II void scan()
{
	freopen(IN,"r",stdin);
	freopen(OUT,"w",stdout);
	fread(buffer,1,1<<23,stdin);
	
	read(N);
	read(Ifreverse);
}

II void rem(treap* &nod)
{
	nod->nr = nod->left->nr + nod->right->nr + 1;
}

II void update(treap* &nod)
{
	if(nod == nil)
		return;
	//nod->nr = nod->left->nr + nod->right->nr + 1;
	
	nod->left->rev ^= nod->rev;
    nod->right->rev ^= nod->rev;

    if (nod->rev) 
	{
        treap *aux = nod->left;  nod->left = nod->right;  nod->right = aux;
        nod->rev ^= 1;
    }
}

II void rotate_left(treap* &nod)
{
	treap *aux = nod->left;
    nod->left = aux->right, aux->right = nod;
    nod = aux;
	
	rem(nod->right);
	rem(nod);
}

II void rotate_right(treap* &nod)
{
	treap *aux = nod->right;
    nod->right = aux->left, aux->left = nod;
    nod = aux;
	
	rem(nod->left);
	rem(nod);
}

II void insert(treap* &nod,int key,int x,int pri)
{
	if(nod == nil)
	{
		nod = new treap(x,pri,1,false,nil,nil);
		return;
	}
	
	update(nod);
	update(nod->left);
	update(nod->right);
	
	++nod->nr;
	if(key <= nod->left->nr + 1)
		insert(nod->left,key,x,pri);
	else
		insert(nod->right,key - nod->left->nr - 1,x,pri);
	
	if(nod->left->pri > nod->pri)
		rotate_left(nod);
	else if(nod->right->pri > nod->pri)
		rotate_right(nod);
}

II void erase(treap* &nod,int key)
{
	if (nod == nil) 
		return;
	
	update(nod);
	update(nod->left);
	update(nod->right);
	
	if(key <= nod->left->nr)
        erase(nod->left, key);
    else if (key > nod->left->nr + 1)
        erase(nod->right, key - nod->left->nr - 1);
    else
	{    
        if (nod->left == nil && nod->right == nil)
        {
			delete nod,nod = nil;
			return;
		}
        else 
		{
            bool ok = (nod->left->pri > nod->right->pri);
			if(ok)
			{
				rotate_left(nod);
				erase(nod->right,key - nod->left->nr - 1);
            }
			else
			{
				rotate_right(nod);
				erase(nod->left,key);
			}
        }
    }
	--nod->nr;
}

II void erase_int(int x,int y)
{
	treap *Tleft,*Tmij,*Tright;
	
	insert(R,x,oo,oo);
	Tleft = R->left;
	Tmij = R->right;
	delete R,R = nil;
	
	insert(Tmij,y - x + 2,oo,oo);
	Tright = Tmij->right;
	delete Tmij,Tmij = nil;
	
	R = new treap(-oo,-oo,Tleft->nr + Tright->nr + 1,false,Tleft,Tright);
	erase(R,Tleft->nr + 1);
}

II void reverse(int x,int y)
{
	treap *Tleft,*Taux,*Tmij,*Tright;
	
	insert(R,x,oo,oo);
	Tleft = R->left;
	Taux = R->right;
	
	insert(Taux,y - x + 2,oo,oo);
	Tmij = Taux->left;
	Tright = Taux->right;
	
	Tmij->rev ^= 1;
	
	R = new treap(-oo,-oo,Tleft->nr + Tright->nr + 1,false,Tleft,Tmij);
	erase(R,Tleft->nr + 1);
	
	Tleft = R;
	
	R = new treap(-oo,-oo,Tleft->nr + Tright->nr + 1,false,Tleft,Tright);
	erase(R,Tleft->nr + 1);
}

II int query(treap* nod,int key)
{
	update(nod);
	update(nod->left);
	update(nod->right);
	
	int mij = nod->left->nr + 1;
	if(mij == key)
		return nod->key;
	return (key < mij) ? query(nod->left,key) : query(nod->right,key - mij);
}

II void DF(treap* nod)
{
	if(nod==nil)
		return;
	
	DF(nod->left);
	printf("%d ",nod->key);
	DF(nod->right);
	
	if(nod == R)
		printf("\n");
}

II void solve()
{
	srand((int)time(0));
	char tip;
	int k,x,y;
	
	nil = new treap(0,-oo,0,false,nil,nil);
	R = nil;
	
	FOR(i,1,N)
	{
		read(tip);
		
		if(tip == 'I')
		{
			read(k);read(x);
			
			int pri = rand() % N + 1;
			insert(R,k,x,pri);
		}
		else if(tip == 'A')
		{
			read(k);
			printf("%d\n",query(R,k) );
		}
		else if(tip == 'R')
		{
			read(x);read(y);
			reverse(x,y);
		}
		else
		{
			read(x);read(y);
			erase_int(x,y);
		}
	}
	
	DF(R);
	
	//printf("Time %d ms\n",clock() );
}

int main()
{
	scan();
	solve();
	return 0;
}