#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <cstring>
#include <chrono>
#include <cassert>
#include <bitset>
#include <stack>
#include <queue>
#include <iomanip>

//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("Ofast,unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define x first
#define y second
#define ld long double
#define ll long long
#define ull unsigned long long
#define us unsigned short
#define lsb(x) ((x) & (-(x)))
#define pii pair <int, int>

using namespace std;

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

struct Treap {
  int key, prio, size;
  bool rev;

  Treap* l, * r;

  Treap(int _key) {
    key = _key;
    prio = rand();
    size = 1;
    rev = 0;
    l = r = NULL;
  }
};

void push(Treap*& t) {
  if (t && t->rev) {
    swap(t->l, t->r);
    t->rev ^= 1;
    if (t->l)
      t->l->rev ^= 1;
    if (t->r)
      t->r->rev ^= 1;
  }
}

int size(Treap* t) {
  return (!t ? 0 : t->size);
}

void split(Treap* t, Treap*& l, Treap*& r, int val) {
  if (!t) {
    l = r = NULL;
    return;
  }

  push(t);

  if (size(t->l) < val) {
    split(t->r, t->r, r, val - size(t->l) - 1);
    l = t;
  }
  else {
    split(t->l, l, t->l, val);
    r = t;
  }

  t->size = 1 + size(t->l) + size(t->r);
}

void merge(Treap*& t, Treap* l, Treap* r) {
  push(l); push(r);

  if (!l) {
    t = r;
    return;
  }
  if (!r) {
    t = l;
    return;
  }

  if (l->prio < r->prio) {
    merge(l->r, l->r, r);
    t = l;
  }
  else {
    merge(r->l, l, r->l);
    t = r;
  }

  t->size = 1 + size(t->l) + size(t->r);
}

int get(Treap* t, int val) {
  push(t);
  if (val == size(t->l) + 1)
    return t->key;

  if (size(t->l) < val) {
    return get(t->r, val - size(t->l) - 1);
  }

  return get(t->l, val);
}

void reverse(Treap* t, int l, int r) {
  Treap* a, * b, * c;

  split(t, a, b, l - 1);
  split(b, b, c, r - l + 1);

  b->rev ^= 1;

  merge(t, a, b);
  merge(t, t, c);
}

void print(Treap* t) {
  if (!t)
    return;

  push(t);
  print(t->l);
  out << t->key << " ";
  print(t->r);
}

int n, m;
int x, y;
char op;

Treap* t, * a, * b, * c;

int main() {
  in >> m >> n;

  for (; m; m--) {
    in >> op >> x;
    /*Treap* a, * b, * c;
    split(t, a, b, l - 1);
    split(b, b, c, r - l + 1);
    merge(t, a, c);
    merge(t, t, b);*/
    if (op == 'I') {
      in >> y;

      split(t, a, b, x - 1);
      merge(a, a, new Treap(y));
      merge(t, a, b);
    }
    else if (op == 'A') {
      out << get(t, x) << "\n";
    }
    else if (op == 'R') {
      in >> y;
      reverse(t, x, y);
    }
    else {
      in >> y;

      split(t, a, b, x - 1);
      split(b, b, c, y - x + 1);
      merge(t, a, c);
    }

    //print(t);
    //cout << "\n";
  }

  print(t);
  return 0;
}