#include <bits/stdc++.h>

using namespace std;

#define FILE_IO

class Treap
{
public:
    struct Node
    {
        int pr;
        int val, sz;
        bool rev;
        Node *l, *r;

        Node()
        {
            pr = val = sz = 0;
            rev = 0;
            l = r = 0;
        }

        Node(int _pr, int _val, Node *_l, Node *_r)
        {
            pr = _pr, val = _val;
            sz = 1; rev = 0;
            l = _l, r = _r;
        }
    };
    Node *R, *nil;

    void init()
    {
        nil = new Node();
        nil -> l = nil -> r = nil;
        R = nil;
    }

    int newPriority()
    {
        int msk = (1 << 9) - 1;
        int x = rand() & msk;
        int y = rand() & msk;
        int z = rand() & msk;
        return (x | (y << 9) | (z << 18));
    }

    void lazy(Node *&T)
    {
        if(T -> rev)
        {
            swap(T -> l, T -> r);
            if(T -> l != nil)   T -> l -> rev ^= 1;
            if(T -> r != nil)   T -> r -> rev ^= 1;
            T -> rev = 0;
        }
    }

    void remake(Node *&T)
    {
        if(T == nil)    return;
        T -> sz = T -> l -> sz + 1 + T -> r -> sz;
    }

    Node* join(Node *&l, Node *&r)
    {
        if(l == nil)    return r;
        if(r == nil)    return l;

        lazy(l); lazy(r);

        if(l -> pr > r -> pr)
        {
            l -> r = join(l -> r, r);
            remake(l);
            return l;
        }
        else
        {
            r -> l = join(l, r -> l);
            remake(r);
            return r;
        }
        return nil;
    }

    pair<Node*, Node*> split(Node *&T, int pos)
    {
        if(T == nil)    return {nil, nil};
        lazy(T);

        if(T -> l -> sz >= pos)
        {
            auto aux = split(T -> l, pos);
            T -> l = aux.second;
            aux.second = T;
            remake(T);
            return aux;
        }
        else
        {
            auto aux = split(T -> r, pos - T -> l -> sz - 1);
            T -> r = aux.first;
            aux.first = T;
            remake(T);
            return aux;
        }

        return {nil, nil};
    }

    void insert(int x, int p)
    {
        Node *nd = new Node(newPriority(), x, nil, nil);
        auto lr = split(R, p - 1);
        Node *lm = join(lr.first, nd);
        R = join(lm, lr.second);
    }

    int access(int p)
    {
        auto lmr = split(R, p - 1);
        auto mr = split(lmr.second, 1);
        int val = mr.first -> val;
        Node *lm = join(lmr.first, mr.first);
        R = join(lm, mr.second);
        return val;
    }

    void reverse(int st, int dr)
    {
        auto lmr = split(R, dr);
        auto lm = split(lmr.first, st - 1);
        lm.second -> rev ^= 1;
        Node *mr = join(lm.second, lmr.second);
        R = join(lm.first, mr);
    }

    void erase(int st, int dr)
    {
        auto lmr = split(R, dr);
        auto lm = split(lmr.first, st - 1);
        R = join(lm.first, lmr.second);
    }

    void printall() { printall(R); printf("\n"); }

    void printall(Node *&T)
    {
        if(T == nil)    return;
        printall(T -> l);
        printf("%d ", T -> val);
        printall(T -> r);
    }
};
Treap trp;

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

	srand(time(0));
    trp.init();
	int Q, op;
	scanf("%d%d\n", &Q, &op);
	for(int q = 1; q <= Q; q++)
    {
        char ch;
        scanf("%c", &ch);
        if(ch == 'I')
        {
            int p, v;
            scanf("%d%d\n", &p, &v);
            trp.insert(v, p);
        }
        else if(ch == 'A')
        {
            int p;
            scanf("%d\n", &p);
            printf("%d\n", trp.access(p));
        }
        else if(ch == 'R')
        {
            int st, dr;
            scanf("%d%d\n", &st, &dr);
            trp.reverse(st, dr);
        }
        else if(ch == 'D')
        {
            int st, dr;
            scanf("%d%d\n", &st, &dr);
            trp.erase(st, dr);
        }
    }
    trp.printall();

	return 0;
}