#include <bits/stdc++.h>

using namespace std;

#define FILE_IO

class treap
{
private:
    const int mod = (1 << 30) - 1;
    struct _node
    {
        int vl, p;
        _node *l, *r;
        int sz, rv;

        _node()
        {
            vl = p = sz = rv = 0;
            l = r = 0;
        }

        _node(int _vl, int _p, _node *_l, _node *_r, int _sz, int _rv)
        {
            vl = _vl;
            p = _p;
            l = _l;
            r = _r;
            sz = _sz;
            rv = _rv;
        }
    } *R, *nil;

    void update(_node *&R)
    {
        R -> sz = R -> l -> sz + 1 + R -> r -> sz;
    }

    int newPriority()
    {
        int x = rand() & mod;
        return (x + 1);
    }

    void reverse(_node *&R)
    {
        if(!R -> rv)    return;
        swap(R -> l, R -> r);
        R -> rv ^= 1;
        if(R -> l != nil)   R -> l -> rv ^= 1;
        if(R -> r != nil)   R -> r -> rv ^= 1;
    }

    _node* merge(_node *&l, _node *&r)
    {
        if(l == nil)    return r;
        if(r == nil)    return l;
        if(l -> rv) reverse(l);
        if(r -> rv) reverse(r);
        if(l -> p > r -> p)
        {
            l -> r = merge(l -> r, r);
            update(l);
            return l;
        }
        else
        {
            r -> l = merge(l, r -> l);
            update(r);
            return r;
        }
        return nil;
    }

    pair <_node*, _node*> split(_node *&R, int pos)
    {
        if(R == nil)
            return {nil, nil};
        if(R -> rv) reverse(R);
        if(pos > R -> l -> sz + 1)
        {
            auto ans = split(R -> r, pos - R -> l -> sz - 1);
            R -> r = ans.first;
            ans.first = R;
            update(R);
            return ans;
        }
        else
        {
            auto ans = split(R -> l, pos);
            R -> l = ans.second;
            ans.second = R;
            update(R);
            return ans;
        }
        return {nil, nil};
    }

    int access(_node *&R, int pos)
    {
        if(pos == R -> l -> sz + 1) return R -> vl;
        if(pos <= R -> l -> sz)
            return access(R -> l, pos);
        else
            return access(R -> r, pos - R -> l -> sz - 1);
        return 0;
    }

    void write(_node *&R)
    {
        if(R == nil)    return;
        if(R -> rv) reverse(R);
        write(R -> l);
        printf("%d ", R -> vl);
        write(R -> r);
    }

public:
    void init()
    {
        nil = new _node();
        nil -> l = nil -> r = nil;
        R = nil;
    }

    void insert(int val, int pos)
    {
        _node *N = new _node(val, newPriority(), nil, nil, 1, 0);
        _node *l, *r;
        auto aux = split(R, pos);
        l = aux.first;
        r = aux.second;
        auto nr = merge(N, r);
        R = merge(l, nr);
    }

    int access(int pos)
    {
        return access(R, pos);
    }

    void reverse(int st, int dr)
    {
        auto aux = split(R, st);
        _node *l = aux.first;
        _node *mr = aux.second;
        aux = split(mr, dr - st + 2);
        _node *m = aux.first;
        _node *r = aux.second;
        m -> rv ^= 1;
        mr = merge(m, r);
        R = merge(l, mr);
    }

    void erase(int st, int dr)
    {
        auto aux = split(R, st);
        _node *l = aux.first;
        _node *mr = aux.second;
        aux = split(mr, dr - st + 2);
        _node *m = aux.first;
        _node *r = aux.second;
        R = merge(l, r);
    }

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

    //srand(time(0));

    trp.init();
    int T, x;
    scanf("%d%d", &T, &x);
    while(T--)
    {
        char op = getchar();
        op = getchar();
        if(op == 'I')
        {
            int val, pos;
            scanf("%d%d", &pos, &val);
            trp.insert(val, pos);
        }
        else if(op == 'A')
        {
            int pos;
            scanf("%d", &pos);
            int ans = trp.access(pos);
            printf("%d\n", ans);
        }
        else if(op == 'R')
        {
            int st, dr;
            scanf("%d%d", &st, &dr);
            trp.reverse(st, dr);
        }
        else if(op == 'D')
        {
            int st, dr;
            scanf("%d%d", &st, &dr);
            trp.erase(st, dr);
        }
    }
    trp.write();

    return 0;
}