#include <iostream>
#include <fstream>
#include <set>
#include <ctime>
#include <random>

using namespace std;

ifstream fin("secv8.in");
ofstream fout("secv8.out");

int q, type;

struct treap_node {
    treap_node *left, *right;
    bool rev;
    int val, sz, prio;
};
treap_node *root;

mt19937 rng(time(0));
set <int> prio_list;
int get_prio()
{
    int x = rng();
    while(prio_list.find(x) != prio_list.end())
        x = rng();
    prio_list.insert(x);
    return x;
}

int get_size(treap_node *node)
{
    if(node == NULL)
        return 0;
    return node->sz;
}

void update_node(treap_node *&node)
{
    if(node == NULL)
        return;
    node->sz = 1 + get_size(node->left) + get_size(node->right);
}

void propag(treap_node *&node)
{
    if(node == NULL)
        return;
    if(node->rev == 0)
        return;
    if(node->left != NULL)
        node->left->rev ^= 1;
    if(node->right != NULL)
        node->right->rev ^= 1;
    swap(node->left, node->right);
    node->rev = 0;
}

treap_node *merge_treap(treap_node *st, treap_node *dr)
{
    propag(st);
    propag(dr);
    if(st == NULL)
        return dr;
    if(dr == NULL)
        return st;
    if(st->prio > dr->prio)
    {
        st->right = merge_treap(st->right, dr);
        update_node(st);
        return st;
    }
    else
    {
        dr->left = merge_treap(st, dr->left);
        update_node(dr);
        return dr;
    }
}

void split_treap(treap_node *node, treap_node *&st, treap_node *&dr, int poz)
{
    if(node == NULL)
    {
        st = NULL;
        dr = NULL;
        return;
    }
    propag(node);
    if(get_size(node->left) < poz)
    {
        split_treap(node->right, node->right, dr, poz - get_size(node->left) - 1);
        st = node;
    }
    else
    {
        split_treap(node->left, st, node->left, poz);
        dr = node;
    }
    update_node(node);
}

void insert_treap(int val)
{
    treap_node *aux = new treap_node;
    *aux = {NULL, NULL, 0, val, 1, get_prio()};
    root = merge_treap(root, aux);
}

int cautbin(treap_node *node, int val)
{
    propag(node);
    if(get_size(node->left) == val - 1)
        return node->val;
    if(get_size(node->left) >= val)
        return cautbin(node->left, val);
    else
        return cautbin(node->right, val - get_size(node->left) - 1);
}

int main()
{
    fin >> q >> type; /// de ce doamne de ce
    while(q--)
    {
        char op;
        int x, y;
        fin >> op;
        if(op == 'I')
        {
            fin >> x >> y;
            treap_node *st, *dr;
            split_treap(root, st, dr, x - 1);
            treap_node *add = new treap_node;
            *add = {NULL, NULL, 0, y, 1, get_prio()};
            dr = merge_treap(add, dr);
            root = merge_treap(st, dr);
        }
        if(op == 'A')
        {
            fin >> x;
            fout << cautbin(root, x) << '\n';
        }
        if(op == 'R')
        {
            fin >> x >> y;
            treap_node *st, *mij, *dr;
            split_treap(root, st, dr, y);
            split_treap(st, st, mij, x - 1);
            if(mij != NULL)
                mij->rev ^= 1;
            dr = merge_treap(mij, dr);
            root = merge_treap(st, dr);
        }
        if(op == 'D')
        {
            fin >> x >> y;
            treap_node *st, *mij, *dr;
            split_treap(root, st, dr, y);
            split_treap(st, st, mij, x - 1);
            root = merge_treap(st, dr);
        }
    }
    int n = root->sz;
    for(int i = 1; i <= n; i++)
        fout << cautbin(root, i) << ' ';
    return 0;
}