/*#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;

const int oo = 1000000000;

struct Treap {
    int Size, Key, Priority, Rev;
    Treap *Left, *Right;

    Treap(int Size, int Key, int Priority, Treap *Left, Treap *Right) {
        this->Size = Size, this->Key = Key, this->Priority = Priority;
        this->Left = Left, this->Right = Right;
        Rev = 0;
    }
};

Treap *R, *NIL;

inline void RevDown(Treap* &Node, int Depth) {
    if (Node == NIL || !Depth)
        return;
    if (Node->Left != NIL)
        Node->Left->Rev ^= Node->Rev;
    if (Node->Right != NIL)
        Node->Right->Rev ^= Node->Rev;
    if (Node->Rev == 1)
        swap(Node->Left, Node->Right), Node->Rev = 0;
    RevDown(Node->Left, Depth - 1), RevDown(Node->Right, Depth - 1);
}

inline void Update(Treap* &Node) {
    if (Node == NIL)
        return;
    Node->Size = Node->Left->Size + 1 + Node->Right->Size;
}

inline void RotLeft(Treap* &Node) {
    Treap *Aux = Node->Right;
    Node->Right = Node->Right->Left;
    Aux->Left = Node;
    Node = Aux;
    Update(Node->Left); Update(Node);
}

inline void RotRight(Treap* &Node) {
    Treap *Aux = Node->Left;
    Node->Left = Node->Left->Right;
    Aux->Right = Node;
    Node = Aux;
    Update(Node->Right); Update(Node);
}

inline void Balance(Treap* &Node) {
    if (Node->Left->Priority > Node->Priority)
        RotRight(Node);
    else if (Node->Right->Priority > Node->Priority)
        RotLeft(Node);
}

void Insert(Treap* &Node, int Pos, int Key, int Priority) {
    if (Node == NIL) {
        Node = new Treap(1, Key, Priority, NIL, NIL);
        return;
    }
    RevDown(Node, 2);
    if (Pos <= Node->Left->Size + 1)
        Insert(Node->Left, Pos, Key, Priority);
    else
        Insert(Node->Right, Pos - Node->Left->Size - 1, Key, Priority);
    Update(Node); Balance(Node);
}

void Erase(Treap* &Node) {
    if (Node == NIL)
        return;
    RevDown(Node, 2);
    if (Node->Left == NIL && Node->Right == NIL) {
        delete Node; Node = NIL;
        return;
    }
    if (Node->Left->Priority >= Node->Right->Priority)
        RotRight(Node);
    else
        RotLeft(Node);
    if (Node->Left->Priority == -1)
        Erase(Node->Left);
    else
        Erase(Node->Right);
    Update(Node);
}

int Acces(Treap* &Node, int Pos) {
    RevDown(Node, 2);
    if (Node == NIL || Node->Left->Size + 1 == Pos)
        return Node->Key;
    if (Pos <= Node->Left->Size)
        return Acces(Node->Left, Pos);
    else
        return Acces(Node->Right, Pos - Node->Left->Size - 1);
}

inline Treap* Join(Treap* &Left, Treap* &Right) {
    Treap* NewR = new Treap(Left->Size + 1 + Right->Size, 0, -1, Left, Right);
    Erase(NewR);
    return NewR;
}

inline void Split(Treap* &Root, Treap* &NewRoot, int Pos) {
    Insert(Root, Pos, 0, oo);
    Treap* Aux = Root;
    NewRoot = Root->Right;
    Root = Root->Left;
    delete Aux;
}

inline void Erase(Treap* &Root, int Left, int Right) {
    Treap *A = Root, *B, *C;
    Split(A, B, Left); Split(B, C, Right + 1 - Left + 1);
    Root = Join(A, C);
}

inline void Reverse(Treap* &Root, int Left, int Right) {
    Treap *A = Root, *B, *C;
    Split(A, B, Left); Split(B, C, Right + 1 - Left + 1);
    B->Rev ^= 1;
    Root = Join(A, B); Root = Join(R, C);
}

void Inorder(Treap* &Node) {
    if (Node == NIL)
        return;
    RevDown(Node, 2);
    Inorder(Node->Left); printf("%d ", Node->Key); Inorder(Node->Right);
}

void Initialize() {
    srand(time(0));
    R = NIL = new Treap(0, 0, 0, NULL, NULL);
}

int main() {
    Initialize();
    assert(freopen("secv8.in", "r", stdin));
    assert(freopen("secv8.out", "w", stdout));
    int M, Rev; assert(scanf("%d %d", &M, &Rev) == 2);
    for (; M > 0; --M) {
        char Type; assert(scanf("\n%c", &Type) == 1);
        if (Type == 'I') {
            int Pos, Key; assert(scanf(" %d %d", &Pos, &Key) == 2);
            Insert(R, Pos, Key, 1 + rand() % (oo - 1));
        }
        if (Type == 'R') {
            int Left, Right; assert(scanf(" %d %d", &Left, &Right) == 2);
            Reverse(R, Left, Right);
        }
        if (Type == 'D') {
            int Left, Right; assert(scanf(" %d %d", &Left, &Right) == 2);
            Erase(R, Left, Right);
        }
        if (Type == 'A') {
            int Pos; assert(scanf(" %d", &Pos) == 1);
            printf("%d\n", Acces(R, Pos));
        }
    }
    Inorder(R); printf("\n");
    return 0;
}
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define inf 2147483647

int n, k, st, dr, e;
char tip;

struct treap {
	int key, priority;
	int rev, d;
	treap *st, *dr;
} *T, *R, *nil, *A, *B, *C;

inline int update(treap *P) {
	return P->st->d + P->dr->d + 1;
}

treap* rotate_left(treap *P) {
	treap *aux = P->dr;
	P->dr = P->dr->st;
	aux->st = P;

	P->d = update(P);
	aux->d = update(aux);

	return aux;
}

treap* rotate_right(treap *P) {
	treap *aux = P->st;
	P->st = P->st->dr;
	aux->dr = P;

	P->d = update(P);
	aux->d = update(aux);

	return aux;
}

void reverse_down(treap *P, int k) {
	if (P == nil || !k) return;

    if (P->rev == 1) {
        treap *aux = P->st;
        P->st = P->dr;
        P->dr = aux;

		if (P->st != nil) P->st->rev = P->st->rev ^ P->rev;
        if (P->dr != nil) P->dr->rev = P->dr->rev ^ P->rev;
		P->rev = 0;
	}

	reverse_down(P->st, k - 1);
	reverse_down(P->dr, k - 1);
}

treap* insert(treap *P) {
	if (P == nil) {
    	P = new treap;

		P->key = e;	P->priority = rand() + 1;
		P->rev = 0;	P->d = 1;
		P->st = P->dr = nil;

		if (tip != 'I') P->priority = inf;
	}
	else {
    	reverse_down(P, 2);

		if (P->st->d + 1 >= k) {
        	P->st = insert(P->st);
			P->d = update(P);

			if (P->st->priority > P->priority)
				P = rotate_right(P);
		}
        else {
			k = k - P->st->d - 1;
			P->dr = insert(P->dr);
			P->d = update(P);

			if (P->dr->priority > P->priority)
				P = rotate_left(P);
		}
	}

	return P;
}

treap* erase(treap *P) {
	if (P->st == nil && P->dr == nil) {
    	delete(P);
		return nil;
	}

	reverse_down(P, 2);

	if (P->st->priority >= P->dr->priority)	P = rotate_right(P);
	else P = rotate_left(P);

	if (P->st->priority == -1) P->st = erase(P->st);
	else P->dr = erase(P->dr);
	P->d = update(P);

	return P;
}

void acces(treap *P) {
	reverse_down(P, 2);

	if (P->st->d >= k) acces(P->st);
	else if (P->st->d < k) {
			k -= P->st->d;
			if (k == 1) printf("%d\n", P->key);
			else {
				k--;
				acces(P->dr);
			}
		 }
}

void split(int st, int dr) {
	A = B = C = nil; e = 0;

	//impart dupa pozitia din stanga
	k = st;

	R = insert(R);
	A = R->st;
	B = R = R->dr;

	//impart dupa pozitia din dreapta
	k = dr - st + 2;

	R = insert(R);
	B = R->st;
	C = R->dr;
}

treap* join(treap *P, treap *Q) {
	T = new treap;

	T->st = P; T->dr = Q;
	T->key = T->rev = 0; T->priority = -1;
	T->d = update(T);

	return erase(T);
}

void afis(treap* P) {
	if (P == nil) return;
	reverse_down(P, 2);

	afis(P->st);
	printf("%d ", P->key);
	afis(P->dr);
}

int main() {
	srand(time(0));

    freopen("secv8.in", "r", stdin);
	freopen("secv8.out", "w", stdout);

	R = nil = new treap;
	nil->st = nil->dr = NULL;
	nil->key = nil->priority = nil->rev = nil->d;

	scanf("%d %d\n", &n, &k);
	for (int i = 1; i <= n; i++) {
    	scanf("%c", &tip);

		if (tip == 'I') {
			scanf("%d %d\n", &k, &e);
			R = insert(R);
		}

		if (tip == 'A') {
			scanf("%d\n", &k);
        	acces(R);
		}

		if (tip == 'R') {
			scanf("%d %d\n", &st, &dr);

        	split(st, dr);
			B->rev ^= 1;
			R = join(A, B);
			R = join(R, C);
		}

		if (tip == 'D') {
        	scanf("%d %d\n", &st, &dr);

			split(st, dr);
			R = join(A, C);
		}
	}

	afis(R);
	printf("\n");

	return 0;
}