#include <bits/stdc++.h>

using namespace std;

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

mt19937 rng(0);

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

        int val;
        bool rev;
    };

    Node new_node(int val = 0)
    {
        return {0, 0, 1, (int)rng(), val, false};
    }

    vector<Node> T;
    int root = 0;
    int cnt = 0;

    void prop(int x)
    {
        if(!x)
            return;
        if(T[x].rev)
        {
            swap(T[x].l, T[x].r);
            T[x].rev = 0;
            T[T[x].l].rev ^= 1;
            T[T[x].r].rev ^= 1;
        }
        T[x].sz = T[T[x].l].sz + T[T[x].r].sz + 1;
    }

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

    pair<int, int> split(int x, auto&& lhs)
    {
        if(!x)
            return {0, 0};
        prop(x);
        int l, r;
        if(lhs(x))
        {
            tie(l, r) = split(T[x].r, lhs);
            T[x].r = l;
            l = x;
        }
        else
        {
            tie(l, r) = split(T[x].l, lhs);
            T[x].l = r;
            r = x;
        }
        prop(x);
        return {l, r};
    }

    pair<int, int> split_by_kth(int x, int k)
    {
        return split(x, [&](int y) {
            int sz = T[T[y].l].sz + 1;
            if(sz <= k)
            {
                k -= sz;
                return true;
            }
            return false;
        });
    }

    int merge(int l, int r)
    {
        if(l == 0 && r == 0)
            return 0;
        prop(l), prop(r);
        if(T[l].pri > T[r].pri)
        {
            T[l].r = merge(T[l].r, r);
            prop(l);
            return l;
        }
        T[r].l = merge(l, T[r].l);
        prop(r);
        return r;
    }

    int find_kth(int x, int k)
    {
        prop(x);
        int sz = T[T[x].l].sz + 1;
        if(k == sz)
            return x;
        if(k < sz)
            return find_kth(T[x].l, k);
        return find_kth(T[x].r, k - sz);
    }

    void insert_at_kth(int k, int val)
    {
        cnt++;
        auto [l, r] = split_by_kth(root, k - 1);
        T.push_back(new_node(val));
        root = merge(l, T.size() - 1);
        root = merge(root, r);
        assert(T[root].sz == cnt);
    }

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

    void delete_itv(int ql, int qr)
    {
        cnt -= qr - ql + 1;
        int l, m, r;
        tie(m, r) = split_by_kth(root, qr);
        tie(l, m) = split_by_kth(m, ql - 1);
        root = merge(l, r);
    }

    void dfs(int x)
    {
        if(!x)
            return;
        prop(x);
        dfs(T[x].l);
        cout << T[x].val << ' ';
        dfs(T[x].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.T[treap.find_kth(treap.root, k)].val << '\n';
        }
        if(t == 'R')
        {
            int i, j;
            cin >> i >> j;
            treap.reverse_itv(i, j);
        }
        if(t == 'D')
        {
            int i, j;
            cin >> i >> j;
            treap.delete_itv(i, j);
        }
    }
    treap.dfs(treap.root);
    return 0;
}