//TC

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <set>
#include <map>

#define forn(a,b,c) for(int (a)=(b);(a)<=(c);(a)++)
#define forr(a,b,c) for(int (a)=(b);(a)>=(c);(a)--)
#define foreach(a,b) for( typeof( (b).begin() ) a=(b).begin(); (a)!=(b).end() ; (a)++ )
#define foreachr(a,b) for( typeof( (b).rbegin() ) a=(b).rbegin(); (a)!=(b).rend() ; (a)++ )
#define dg(x)  cerr <<#x<<':'<<x<<" "
#define dbg(x)  cerr <<#x<<':'<<x<<endl
#define SET(A,b) memset(A,b,sizeof (A) )
#define SIZE(A) ((int)(A).size())
#define ALL(A) (A).begin(),(A).end()
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define num(a) (1LL<<(a))
using namespace std;

typedef double dbl;
typedef long long Lint;
typedef pair<int,int> ii;
typedef pair<Lint,Lint> Lii;

const Lint mod = 1e9;

const int MAXN = 200010;

int cnt;

struct node{
	int L,R,v,h,size,rev;
	node(int _v=0){
		v=_v;h=rand();
		if(h==0)	h++;
		L=0,R=0,size=1;
	}
}T[MAXN];

void upd( int k ){
	if(!k)	return;
	//~ printf("upd %d\n",k);
	T[k].size= T[ T[k].L ].size + T[ T[k].R ].size + 1;
	if(T[k].rev%2){
		T[k].rev=0;
		swap( T[k].L,T[k].R );
		T[ T[k].L ].rev++;
		T[ T[k].R ].rev++;
	}
	//~ printf("%d\n",T[k].size);
}

ii split(int root,int k){
	if(root==0)
		return ii(0,0);
	upd(root);
	int s = T[ T[root].L ].size+1;
	ii tmp;
	if(k<s){
		tmp=split( T[root].L , k );
		T[root].L=tmp.se;
		upd(root);
		return ii(tmp.fi,root);
	}
	else{
		tmp=split( T[root].R , k-s );
		T[root].R=tmp.fi;
		upd(root);
		return ii(root,tmp.se);
	}
}
int merge(int L,int R){
	//~ printf("merge %d %d\n",L,R);
	upd(L);
	upd(R);
	int root=0;
	if(L==0 && R==0)	return 0;
	if( T[L].h > T[R].h ){
		root=L;
		T[root].R=merge( T[L].R,R );
	}
	else{
		root=R;
		T[root].L=merge( L,T[R].L );
	}
	upd(root);
	return root;
}

void reverse(int *root,int b,int e){
	
	ii x,y;
	x=split( *root,e );
	y=split( x.fi,b-1 );
	T[y.se].rev^=1;
	int k=merge(y.fi,y.se);
	*root=merge(k,x.se);
	
}

void insert(int* root,int k,int e){
	ii x=split(*root,k-1);
	T[++cnt]=node(e);
	int f=merge( x.fi,cnt );
	*root=merge( f,x.se );
}

void remove( int *root,int b,int e ){
	ii x,y;
	x=split( *root,e );
	y=split( x.fi,b-1 );
	*root=merge( y.fi,x.se );
}

int access(int root,int k){
	//~ printf("%d %d %d\n",root,T[root].size,k);
	//~ system( "sleep 1");
	upd(root);
	int s=T[T[root].L].size+1;
	if(k<s)
		return access( T[root].L,k );
	if(k==s)
		return T[root].v;
	return access( T[root].R,k-s );
}

int main(){
	
	freopen("secv8.in","r",stdin);
	freopen("secv8.out","w",stdout);
	
	srand(time(0));
	
	SET(T,0);
	T[0].size=0;
	
	int n,k;
	
	scanf("%d %d",&n,&k);
	
	int root=0;
	
	char ch;
	int a,b;
	
	forn(i,1,n)
	{
		scanf(" %c",&ch);
		//~ printf("%c\n",ch);
		if(ch=='I')
		{
			scanf("%d %d",&a,&b);
			insert(&root,a,b);
		}
		if(ch=='A')
		{
			scanf("%d",&a);
			cout << access(root,a) << endl;;
		}
		if(ch=='R')
		{
			scanf("%d %d",&a,&b);
			reverse(&root,a,b);
		}
		if(ch=='D'){
			scanf("%d %d",&a,&b);
			remove(&root,a,b);
		}
		
		//~ dbg(T[0].size);
		//~ forn(i,1,cnt)
			//~ printf("%d ",T[i].size);
		//~ puts("");
		//~ puts("");
		
	}
	
	forn(i,1,T[root].size)
		printf("%d ",access(root,i));
	puts("");
	
	return 0;
	
}