#include <bits/stdc++.h>
 
using namespace std;
 
ifstream in("secv8.in");
ofstream out("secv8.out");
 
const int MOD = 1000*1000*1000 + 7;
 
struct node
{
    int cnt, val, priority;
    bool ok;
    node *left, *right;
 
    node(int val, int priority) {
        this -> ok = false;
        this -> cnt = 1;
        this -> val = val;
        this -> priority = priority;
        this -> left= NULL;
        this -> right= NULL;
    }
};
 
node * rad;
 
void lazyup(node *&n) 
{
    if(n && n->ok) 
	{
        swap(n->left,n->right);
        n->ok = 0;
 
        if(n -> left)
            n -> left -> ok ^= 1;
 
        if(n -> right)
            n -> right -> ok ^= 1;
    }
}
 
void afisare(node *n) {
    	if(n == NULL) return;
 
	lazyup(n);
 
    	afisare(n -> left);
    	out << n -> val << " ";
	afisare(n -> right);
}
 
int getCnt(node *& n) 
{
	if(n == NULL)
		return 0;
	return n -> cnt;
}
 
void update(node *& n) 
{
	if(n== NULL)
        	return;
 
    	n -> cnt = 1 + getCnt(n -> left) + getCnt(n -> right);
}
 
void split(node * n, node *& tree1, node *& tree2, int key, int add) 
{
   	if(n == NULL) 
	{
        	tree1 = tree2 = NULL;
        	return;
    	}
 
    	lazyup(n);
    	int aux = add + getCnt(n -> left) + 1;
 
    	if(aux <= key) 
	{
        	tree1 = n;
        	split(n -> right, tree1 -> right, tree2, key, aux);
    	}
    	else 
	{
        	tree2 = n;
       		split(n -> left, tree1, tree2 -> left, key, add);
    	}
    	update(n);
}
 
void join(node *& n, node * tree1, node * tree2) 
{
    	lazyup(tree1);
    	lazyup(tree2);
 
    	if(tree1 == NULL || tree2 == NULL) 
        	n = (tree1 == NULL) ? tree2 : tree1;
    	else if(tree1 -> priority > tree2 -> priority) 
	{
        	n = tree1;
        	join(n -> right, tree1 -> right, tree2);
    	}
    	else 
	{
        	n = tree2;
        	join(n -> left, tree1, tree2 -> left);
    	}
 
    	update(n);
}
 
void insert(node *& n, node * newNode, int pos) 
{
    	node * tree1, * tree2;
 
    	split(n, tree1, tree2, pos - 1, 0);
    	join(tree1, tree1, newNode);
    	join(n, tree1, tree2);
}


void erase(node *& n, int x, int y) 
{
    	node * tree1 = NULL, * tree2 = NULL, * tree3 = NULL;
 
    	split(n, tree1, tree3, y, 0);
    	split(tree1, tree1, tree2, x - 1, 0);
 
    	join(n, tree1, tree3);
}
 

void reverse(node*& n, int x, int y) 
{
    	node * tree1 = NULL, * tree2 = NULL, * tree3 = NULL;
 
    	split(n, tree1, tree3, y, 0);
    	split(tree1, tree1, tree2, x - 1, 0);
 
    	tree2 -> ok ^= 1;
 
    	join(n, tree1, tree2);
    	join(n, n, tree3);
}
 

int access(node *n, int pos) 
{
    	node * tree1 = NULL, * tree2 = NULL, * tree3 = NULL;
 
    	split(n, tree1, tree3, pos, 0);
    	split(tree1, tree1, tree2, pos - 1, 0);
 
    	int ans = tree2 -> val;
    	join(n, tree1, tree2);
    	join(n, n, tree3);
 
    	return ans;
}
 
int randomtime() 
{
    	return 1LL * rand() * rand() % MOD;
}
 
int main()
{
    	srand(time(NULL));
 
    	int x, y, t;
    	char type;
    	in >> t >> x;
 
    	while(t--) 
	{
        	in >> type >> x;
 
        	if(type == 'I') 
		{
            		in >> y;
            		node * newNode = new node(y, randomtime());
            		insert(rad, newNode, x);
        	}
 
        	if(type == 'A')
            		out << access(rad, x) << '\n';
 
        	if(type == 'R') 
		{
            		in >> y;
            		reverse(rad, x, y);
        	}
 	
        	if(type == 'D') 
		{
            		in >> y;
            		erase(rad, x, y);
        	}
    	}
    	afisare(rad);
 
    	return 0;
}