#include <fstream>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <cassert>
using namespace std;

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

struct treap {
    int pr, sum, val;
    bool rev;
    treap *l,  *r;
    treap(int, int);
    treap(int _val = 0) {
        rev = false;
        pr = rand();
        sum = 1;
        val = _val;
        l = r = NULL;
    }
};

int getsum(treap *t) {
    if(t) {
        return t->sum;
    }
    return 0;
}

void calcsum(treap *t) {
    if(t) {
        t->sum = 1 + getsum(t->l) + getsum(t->r);
    }
}

void addrev(treap *t) {
    if(!t) {
        return;
    }
    t->rev = 1 - t->rev;
}

void rot(treap *t) {
    if(!t) {
        return;
    }
    if(t->rev) {
        swap(t->l, t->r);
        t->rev = false;
        addrev(t->l);
        addrev(t->r);
    }
}

/* sparge treapul t in 2 treapuri, l (elemente <= key), r(elemente > key) */

void split(treap *t, int key, treap * &l, treap * &r) {
    if(!t) {
        l = r = NULL;
        return;
    }
    rot(t);
    int leftsum = getsum(t->l) + 1;
    if(key <= leftsum) {
        split(t->l, key, l, t->l);
        r = t;
    }
    else {
        split(t->r, key - leftsum, t->r, r);
        l = t;
    }
    calcsum(t);
}

void insert(treap * &t, treap *it, int cat) {
    if(!t) {
        t = it;
        return;
    }
    rot(t);
    if(it->pr > t->pr) {
        split(t, cat, it->l, it->r);
        t = it;
    }
    else {
        int sumleft = getsum(t->l) + 1;
        if(cat <= sumleft) {
            insert(t->l, it, cat);
        }
        else {
            insert(t->r, it, cat - sumleft);
        }
    }

    calcsum(t);
}

void merge(treap * &t, treap *l, treap *r) {
    if(!r || !l) {
        t = l ? l : r;
        return;
    }
    rot(l);
    rot(r);

    if(l->pr > r->pr) {
        merge(l->r, l->r, r);
        t = l;
    }
    else {
        merge(r->l, l, r->l);
        t = r;
    }
    calcsum(t);
}

void erase(treap * &t, int key) {
    rot(t);
    int leftsum = getsum(t->l);
    if(leftsum + 1 == key) {
        treap *l = t->l;
        treap *r = t->r;
        delete t;
        merge(t, l, r);
    }
    else if(key <= leftsum) {
        erase(t->l, key);
    }
    else {
        erase(t->r, key - leftsum - 1);
    }
    calcsum(t);
}

int search(treap *t, int key) {
    rot(t);
    int leftsum = getsum(t->l);
    if(key == leftsum + 1) {
        return t->val;
    }
    if(key <= leftsum) {
        return search(t->l, key);
    }
    return search(t->r, key - leftsum - 1);
}

treap *R;

void print(treap *t) {
    if(!t) {
        return;
    }
    print(t->l);
    fout << t->val << ' ';
    print(t->r);
}

int getv(treap *t) {
    if(t) {
        return t->val;
    }
    return 0;
}

void printv(treap *t) {
    if(!t) {
        return;
    }
    fout << t->val << ' ' << getv(t->l) << '\n';
    fout << t->val << ' ' << getv(t->r) << '\n';
    printv(t->l);
    printv(t->r);
}

int main() {
    int n, p;
    fin >> n >> p;
    for(int i = 1; i <= n; i++) {
        char c;
        fin >> c;
        if(c == 'I') {
            int poz, val;
            fin >> poz >> val;
            insert(R, new treap(val), poz);
           // fout << search(R, poz) << '\n';
        }
        else if(c == 'D') {
            int x, y;
            fin >> x >> y;
            for(int j = y; j >= x; j--) {
                erase(R, j);
            }
        }
        else if(c == 'A') {
            int poz;
            fin >> poz;
            fout << search(R, poz) << '\n';
        }
        else {
            int x, y;
            fin >> x >> y;
            treap *l, *r, *l1, *r1;
            split(R, y + 1, l, r);
            split(l, x, l1, r1);
           // assert(getsum(l1) == y - x + 1);
            addrev(r1);
            merge(l, l1, r1);
            merge(R, l, r);
        }
      /*  printv(R);
        print(R);
        fout <<'\n';
        fout <<'\n';*/
    }
    print(R);
    fout << '\n';

    return 0;
}