#include <bits/stdc++.h>
#define maxN 100002
#define pnn pair<Nod*, Nod*>
using namespace std;
int useless, m, tsize;

FILE *fin = freopen("secv8.in", "r", stdin);
FILE *fout = freopen("secv8.out", "w", stdout);

struct Nod
{
    Nod* st;
    Nod* dr;
    int val, rev;
    long long key;
    int size;
};
Nod* emptyNode;
Nod* rad;
bool isEmptyNode(Nod* rad)
{
    return rad == emptyNode;
}
void recompute(Nod* nod)
{
    if (nod == emptyNode)
        return ;
    nod->size = nod->st->size + 1 + nod->dr->size;
    if (nod->rev == 1)
    {
        nod->rev = 0;
        Nod* aux = nod->st;
        nod->st = nod->dr;
        nod->dr = aux;
        if (nod->st != emptyNode)
            nod->st->rev = !nod->st->rev;
        if (nod->dr != emptyNode)
            nod->dr->rev = !nod->dr->rev;
    }
}


pnn split(Nod* rad, int sizeFirst)
{
    recompute(rad);
    if (!(0 <= sizeFirst && sizeFirst <= rad->size))
        while (1);
    pair<Nod*, Nod*> answer;
    if (isEmptyNode(rad))
        answer.first = answer.second = emptyNode;
    else if (rad->st->size < sizeFirst)
    {
        pair<Nod*, Nod*> p = split(rad->dr, sizeFirst - rad->st->size - 1);
        answer.first = rad;
        rad->dr = p.first;
        answer.second = p.second;
        recompute(rad);
    }
    else // if (sizeFirst <= rad->st->size)
    {
        pair<Nod*, Nod*> p = split(rad->st, sizeFirst);
        answer.second = rad;
        rad->st = p.second;
        answer.first = p.first;
        recompute(rad);
    }


    return answer;
}


Nod* join(Nod* first, Nod* second)
{
    recompute(first);
    recompute(second);
    if (isEmptyNode(first))
        return second;
    if (isEmptyNode(second))
        return first;
    if (second->key > first->key)
    {
        second->st = join(first, second->st);
        recompute(second);
        return second;
    }
    else   // second->key <= first->key
    {
        first->dr = join(first->dr, second);
        recompute(first);
        return first;
    }
}
Nod* insert(Nod* rad, int index, int val)
{
    //recompute(rad);
    if(!(0 <= index && index <= rad->size))
        while (1);
    Nod* nodNou = new Nod();
    nodNou->val = val;
    nodNou->st = nodNou->dr = emptyNode;
    nodNou->key =((long long)rand() << 45
                  ^ (long long)rand() << 30
                  ^ (long long)rand() << 15
                  ^ (long long)rand() <<  0)
                 & 0x7fffffffffffffff;
    nodNou->size = 1;
    nodNou->rev = 0;
    pair<Nod*, Nod*> p = split(rad, index);
    //recompute(p.first); recompute(p.second);
    return join(join(p.first, nodNou), p.second);
}
void update(Nod *rad, int x1, int x2)
{
    recompute(rad);
    pair<Nod*, Nod*> p = split(rad, x2);
    pair<Nod*, Nod*> q = split(p.first, x1);
    q.second->rev = !q.second->rev;
    //recompute(q.second);
    join(join(q.first, q.second), p.second);
    //recompute(rad);
}
int getKthElement(Nod* &rad, int index)
{
    recompute(rad);
    if (!(0 <= index && index < rad->size))
        while (1);
    if (rad->st->size < index)
        return getKthElement(rad->dr, index - rad->st->size - 1);
    else if (rad->st->size == index)
        return rad->val;
    else // if (index < rad->st->size)
        return getKthElement(rad->st, index);
}

void deleteAll(Nod* rad)
{
    if (rad != emptyNode)
    {
        deleteAll(rad->st);
        deleteAll(rad->dr);
        delete rad;
    }
}
Nod* eraseAll(Nod* rad, int x1, int x2)
{
    assert(0 <= x1 && x1 < x2 && x2 <= rad->size);
    pair<Nod*, Nod*> p = split(rad, x2);
    pair<Nod*, Nod*> q = split(p.first, x1);
    deleteAll(q.second);
    return join(q.first, p.second);
}

void read()
{
    scanf("%d %d", &m, &useless);
}
void write()
{
    while (m --)
    {
        int k, e, x, y;
        char q;
        scanf("\n%c", &q);
        if (q == 'I')
        {
            scanf("%d %d", &k, &e);
            rad = insert(rad, k - 1, e);
            ++ tsize;
        }
        else if (q == 'A')
        {
            scanf("%d", &k);
            printf("%d\n", getKthElement(rad, k - 1));
        }
        else if (q == 'R')
        {
            scanf("%d %d", &x, &y);
            if (x > y)
                swap(x, y);
            if (x != y)
                update(rad, x - 1, y);
        }
        else if (q == 'D')
        {
            scanf("%d %d", &x, &y);
            tsize -= (y - x + 1);
            if (x > y)
                swap(x, y);
            rad = eraseAll(rad, x - 1, y);
        }
    }
    for (int k = 0; k < tsize; ++ k)
        printf("%d ", getKthElement(rad, k));
}
int main()
{
    emptyNode = new Nod();
    emptyNode->val = 0;
    emptyNode->key = -1;
    emptyNode->st = emptyNode;
    emptyNode->dr = emptyNode;
    emptyNode->size = 0;
    emptyNode->rev = 0;
    rad = emptyNode;
    read();
    //solve();
    write();
    return 0;
}