#include <fstream>
#include <algorithm>
#include <random>
#include <ctime>


using namespace std;

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

int N, aux;


struct node {
	node *st, *dr;

	int val, priority, size;

	bool reversed;
} nil;

node* reverse(node *n) {

	n->reversed = !n->reversed;
	swap(n->st, n->dr);

	return n;
}

node* prop(node* n) {
	if (n->reversed && n != &nil) {
		n->reversed = false;

		n->st = reverse(n->st);
		n->dr = reverse(n->dr);

	}

	return n;
}

node *mod_fiu(node *n, int care, node* fiu) {
	if (care == 0) n->st = fiu;
	else n->dr = fiu;

	n->size = n->st->size + n->dr->size + 1;

	return n;
}

node *join(node *st, node *dr) {
	st = prop(st);
	dr = prop(dr);

	if (st == &nil) return dr;
	if (dr == &nil) return st;

	if (st->priority < dr->priority)
		return mod_fiu(dr, 0, join(st, dr->st));
	return mod_fiu(st, 1, join(st->dr, dr));
}

pair<node*, node*> split(node *n, int k) {
	n = prop(n);
	if (n == &nil) return { &nil, &nil };

	if (n->st->size >= k) {
		auto t = split(n->st, k);
		return { t.first, mod_fiu(n, 0, t.second) };
	}


	auto t = split(n->dr, k - n->st->size - 1);
	return { mod_fiu(n, 1, t.first), t.second };
}


node *insert(node *n, int poz, int val) {
	n = prop(n);
	pair <node*, node*> sp = split(n, poz);

	node *now = new node;
	*now = { &nil, &nil, val, rand(), 1, 0 };

	return join(join(sp.first, now), sp.second);
}

int get (node *n, int poz) {
    n = prop(n);
    auto t1 = split(n, poz + 1);
    auto t2 = split(t1.first, poz);
 
    n = join(join(t2.first, t2.second), t1.second);
 
    return t2.second->val;
}

node *reverseOP (node *n, int st, int dr) {
    n = prop(n);
    auto t1 = split(n, dr+1);
    auto t2 = split(t1.first, st);
 
    t2.second = reverse(t2.second);
 
    return join(join(t2.first, t2.second), t1.second);
}

node *remove (node *n, int st, int dr) {
    n = prop(n);
    auto t1 = split(n, dr + 1);
    auto t2 = split(t1.first, st);
 
    return join(t2.first, t1.second);
}
int main()
{
    srand(time(NULL));
	f >> N >> aux;

	node *rad = &nil;

	char ch;
	int st, dr, poz, val;


	for (int i = 0; i < N; i++) {
		f >> ch;

		if (ch == 'I') {
			f >> poz >> val;
			rad = insert(rad, poz - 1, val);
		} else if (ch == 'A') {
			f >> poz;
			g << get(rad, poz - 1) << "\n";
		} else if (ch == 'R') {
			f >> st >> dr;
            rad = reverseOP(rad, st - 1, dr - 1);
        } else if (ch == 'D') {
            f >> st >> dr;
            rad = remove(rad, st - 1, dr - 1);
        }
	}
	
	for (int i = 0; i < rad->size; i++) {
		g << get(rad, i) << " ";
	}
	g << "\n";
	return 0;
}