#include <bits/stdc++.h>

using namespace std;

using pii = pair<int, int>;

const int INF = 1e9;

#define cin fin
#define cout fout
ifstream cin("secv8.in");
ofstream cout("secv8.out");

mt19937 rng(time(NULL));

struct Treap
{
    struct Node
    {
        int l, r, sz;
        int prio;

        int s;
        bool rev;
    };

    vector<Node> T;

    int new_node(int s)
    {
        T.push_back((Node){0, 0, 1, (int)rng(), s});
        return T.size() - 1;
    }

    int root = 0;

    void init()
    {
        T.clear();
        T.push_back({0, 0, 0, INT_MIN, 0});
    }

    void pull(int i)
    {
        if(!i)
            return;
        T[i].sz = 1 + T[T[i].l].sz + T[T[i].r].sz;
    }

    void push(int i)
    {
        if(!i)
            return;
        if(T[i].rev)
        {
            swap(T[i].l, T[i].r);
            T[T[i].l].rev ^= 1;
            T[T[i].r].rev ^= 1;
            T[i].rev = 0;
        }
    }

    pii split(int i, auto&& lhs)
    {
        if(i == 0)
            return {0, 0};
        push(i);
        int l, r;
        if(lhs(i))
        {
            tie(l, r) = split(T[i].r, lhs);
            T[i].r = l;
            l = i;
        }
        else
        {
            tie(l, r) = split(T[i].l, lhs);
            T[i].l = r;
            r = i;
        }
        pull(l), pull(r);
        return {l, r};
    }

    pii split_by_kth(int i, int k)
    {
        return split(i, [&](int j) {
            int sz = T[T[j].l].sz + 1;
            if(sz <= k)
            {
                k -= sz;
                return true;
            }
            return false;
        });
    }

    int merge(int l, int r)
    {
        if(!l && !r)
            return 0;
        push(l), push(r);
        if(T[l].prio > T[r].prio)
        {
            T[l].r = merge(T[l].r, r);
            pull(l);
            return l;
        }
        T[r].l = merge(l, T[r].l);
        pull(r);
        return r;
    }

    void insert_at_kth(int k, int s)
    {
        auto [l, r] = split_by_kth(root, k - 1);
        root = merge(l, new_node(s));
        root = merge(root, r);
    }

    void erase(int ql, int qr)
    {
        int l, mid, r;
        tie(mid, r) = split_by_kth(root, qr);
        tie(l, mid) = split_by_kth(mid, ql - 1);
        root = merge(l, r);
    }

    void reverse(int ql, int qr)
    {
        int l, mid, r;
        tie(mid, r) = split_by_kth(root, qr);
        tie(l, mid) = split_by_kth(mid, ql - 1);
        T[mid].rev ^= 1;
        root = merge(l, mid);
        root = merge(root, r);
    }

    int dfs_kth(int i, int k)
    {
        push(i);
        int sz = T[T[i].l].sz + 1;
        if(k == sz)
            return T[i].s;
        if(k < sz)
            return dfs_kth(T[i].l, k);
        return dfs_kth(T[i].r, k - sz);
    }

    int access_at_kth(int k)
    {
        return dfs_kth(root, k);
    }

    void output(int i)
    {
        if(!i)
            return;
        push(i);
        output(T[i].l);
        cout << T[i].s << ' ';
        output(T[i].r);
    }
};

Treap treap;

int32_t main()
{
    int q, yap;
    cin >> q >> yap;
    treap.init();
    for(int i = 1; i <= q;i ++)
    {
        char t;
        cin >> t;
        if(t == 'I')
        {
            int k, e;
            cin >> k >> e;
            treap.insert_at_kth(k, e);
        } 
        if(t == 'A')
        {
            int k;
            cin >> k;
            cout << treap.access_at_kth(k) << '\n';
        }
        if(t == 'R')
        {
            int i, j;
            cin >> i >> j;
            treap.reverse(i, j);
        }
        if(t == 'D')
        {
            int i, j;
            cin >> i >> j;
            treap.erase(i, j);
        }
    }
    treap.output(treap.root);
    return 0;
}