#include <bits/stdc++.h>

using namespace std;

#define FILE_IO

namespace SplayTree
{
    struct Node
    {
        int val = 0, sz = 0;
        bool rev = 0;
        Node *l = 0, *r = 0, *f = 0;

        Node() { ; }
        Node(int _val, Node* _l, Node* _r, Node* _f)
        {
            val = _val, sz = 1, rev = 0, l = _l, r = _r, f = _f;
        }

        ~Node() { ; }
    };
    Node *nil, *R;

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

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

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

    void rotl(Node* T)
    {
        if(T == nil)    return;
        T -> r -> f = T -> f;
        Node* aux = T -> r -> l;
        T -> r -> l = T;
        T -> f = T -> r;
        T -> r = aux;
        T -> r -> f = T;
        if(T -> f -> f != nil)
        {
            Node* f = T -> f -> f;
            if(f -> l == T)    f -> l = T -> f;
            if(f -> r == T)    f -> r = T -> f;
        }
        remake(T);
        remake(T -> f);
    }

    void rotr(Node* T)
    {
        if(T == nil)    return;
        T -> l -> f = T -> f;
        Node* aux = T -> l -> r;
        T -> l -> r = T;
        T -> f = T -> l;
        T -> l = aux;
        T -> l -> f = T;
        if(T -> f -> f != nil)
        {
            Node* f = T -> f -> f;
            if(f -> l == T)    f -> l = T -> f;
            if(f -> r == T)    f -> r = T -> f;
        }
        remake(T);
        remake(T -> f);
    }

    void splay(Node* T)
    {
        if(T == nil)    return;
        while(T -> f != nil)
        {
            Node* f = T -> f;
            if(f -> f == nil)
            {
                if(f -> l == T) rotr(f);
                else    rotl(f);
                continue;
            }
            Node* ff = f -> f;
            if(ff -> l == f)
            {
                if(f -> l == T) rotr(ff), rotr(f);
                else rotl(f), rotr(ff);
            }
            else
            {
                if(f -> l == T) rotr(f), rotl(ff);
                else rotl(ff), rotl(f);
            }
        }
        R = T;
    }

    void splay(int p)
    {
        Node* T = R;
        if(T == nil)    return;
        while(1)
        {
            lazy(T);
            if(T -> l -> sz >= p)
            {
                if(T -> l == nil)   return;
                T = T -> l;
            }
            else if(T -> l -> sz + 1 == p)
                break;
            else
            {
                p -= T -> l -> sz + 1;
                if(T -> r == nil)   return;
                T = T -> r;
            }
        }
        splay(T);
    }

    void insert(int x, int p)
    {
        if(R == nil)
        {
            R = new Node(x, nil, nil, nil);
            return;
        }
        Node* T = R;
        while(1)
        {
            lazy(T);
            if(T -> l -> sz >= p)
            {
                if(T -> l == nil)
                {
                    T -> l = new Node(x, nil, nil, T);
                    splay(T -> l);
                    break;
                }
                T = T -> l;
            }
            else
            {
                p -= T -> l -> sz + 1;
                if(T -> r == nil)
                {
                    T -> r = new Node(x, nil, nil, T);
                    splay(T -> r);
                    break;
                }
                T = T -> r;
            }
        }
    }

    int getval(int p)
    {
        splay(p);
        return R -> val;
    }

    void erase(int st, int dr)
    {
        splay(dr);
        Node* r = R -> r;
        if(r != nil) r -> f = nil;
        R -> r = nil;

        splay(st);
        Node* l = R -> l;
        if(l != nil) l -> f = nil;
        R -> l = nil;

        R = l;
        if(l == nil && r == nil)    return;
        if(r == nil)    return;
        if(l == nil) { R = r; return; }

        splay(l -> sz);

        R -> r = r;
        if(R -> r != nil)   R -> r -> f = R;
        remake(R);
    }

    void reverse(int st, int dr)
    {
        splay(dr);
        Node* r = R -> r;
        if(r != nil)    r -> f = nil;
        R -> r = nil;

        splay(st);
        Node* l = R -> l;
        if(l != nil)    l -> f = nil;
        R -> l = nil;

        R -> rev ^= 1;
        lazy(R);
        remake(R);

        splay(1);
        R -> l = l;
        if(R -> l != nil)   R -> l -> f = R;
        remake(R);

        splay(R -> sz);
        R -> r = r;
        if(R -> r != nil)   R -> r -> f = R;
        remake(R);
    }

    void print(Node* T)
    {
        if(T == nil)    return;
        lazy(T);
        print(T -> l);
        printf("%d ", T -> val);
        print(T -> r);
    }

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


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

    SplayTree::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);
            SplayTree::insert(v, p - 1);
        }
        else if(ch == 'A')
        {
            int p;
            scanf("%d\n", &p);
            printf("%d\n", SplayTree::getval(p));
        }
        else if(ch == 'R')
        {
            int st, dr;
            scanf("%d%d\n", &st, &dr);
            SplayTree::reverse(st, dr);
        }
        else if(ch == 'D')
        {
            int st, dr;
            scanf("%d%d\n", &st, &dr);
            SplayTree::erase(st, dr);
        }
    }
    SplayTree::print();

    return 0;
}