#include <bits/stdc++.h>
using namespace std;

struct nod{
	unsigned int key, size, prio, flip;
	nod *l, *r; } nil {};

void prop(nod *n){
	if(n->flip){
		n->flip = 0;
		swap(n->l, n->r);
		n->l->flip ^= 1;
		n->r->flip ^= 1; } }

void dfs(nod *n, ostream& g){
	if(n == &nil) return;
	prop(n);
	dfs(n->l, g);
	g << n->key << ' ';
	dfs(n->r, g); }

nod *join(nod *l, nod *r){
	if(l == &nil) return r;
	if(r == &nil) return l;
	prop(l), prop(r);
	if(l->prio >= r->prio){
		l->size += r->size;
		l->r = join(l->r, r);
		return l; }
	else{
		r->size += l->size;
		r->l = join(l, r->l);
		return r; } }

pair<nod*, nod*> split(nod *n, const int poz){
	if(n == &nil) return make_pair(&nil, &nil);
	prop(n);
	if(n->l->size == poz){
		nod *aux = n->l;
		n->l = &nil;
		n->size -= aux->size;
		return make_pair(aux, n); }
	else if(n->l->size < poz){
		pair<nod*, nod*> tmp = split(n->r, poz - n->l->size - 1);
		n->r = tmp.first;
		tmp.first = n;

		n->size -= tmp.second->size;
		return tmp; }
	else{
		pair<nod*, nod*> tmp = split(n->l, poz);
		n->l = tmp.second;
		tmp.second = n;

		n->size -= tmp.first->size;
		return tmp; } }

unsigned int access(nod *n, const int poz){
	prop(n);
	if(n->l->size == poz) return n->key;
	else if(n->l->size > poz) return access(n->l, poz);
	else return access(n->r, poz - n->l->size - 1); }

nod *insert(nod *n, const int poz, const int key){
	pair<nod*, nod*> p = split(n, poz);
	return join(join(p.first, new nod { key, 1, rand(), 0, &nil, &nil }), p.second); }

tuple<nod*, nod*, nod*> three_way_split(nod *n, const int p1, const int p2){
	pair<nod*, nod*> p = split(n, p2), _p = split(p.first, p1);
	return make_tuple(_p.first, _p.second, p.second); }

nod *erase(nod *n, const int p1, const int p2){
	auto p = three_way_split(n, p1, p2);
	return join(get<0>(p), get<2>(p)); }

nod *reverse(nod *n, const int p1, const int p2){
	auto p = three_way_split(n, p1, p2);
	get<1>(p)->flip ^= 1;
	return join(join(get<0>(p), get<1>(p)), get<2>(p)); }

constexpr int bufsz = 1e5;

int main(){
	srand(time(nullptr));
	ifstream f("secv8.in");
	ofstream g("secv8.out");
	char ibuf[bufsz] = {}, obuf[bufsz] = {};
	f.rdbuf()->pubsetbuf(ibuf, bufsz);
	g.rdbuf()->pubsetbuf(obuf, bufsz);
	int n, xxx;

	f >> n >> xxx;

	nod *rad = &nil;

	for(unsigned int poz, key, p1, p2; n--; ){
		char ch;
		f >> ch;
		if(ch == 'I'){
			f >> poz >> key;
			rad = insert(rad, poz-1, key); }
		else if(ch == 'A'){
			f >> poz;
			g << access(rad, poz-1) << '\n'; }
		else if(ch == 'R'){
			f >> p1 >> p2;
			rad = reverse(rad, p1-1, p2); }
		else{
			f >> p1 >> p2;
			rad = erase(rad, p1-1, p2); } }

	dfs(rad, g);

	return 0; }