#include <cstdio>
#include <algorithm>
#include <ctime>
#include <cstdlib>

using namespace std;

struct Node {
  int val;
  int sz;
  int pr;
  Node* left;
  Node* right;
  bool rev;
};

Node* emptyNode = new Node{0, 0, -1, NULL, NULL, 0};

typedef pair<Node*, Node*> p;

void unreverse(Node* root) {
  if (root != emptyNode && root->rev == true) {
    swap(root->left, root->right);
    root->left->rev = !root->left->rev;
    root->right->rev = !root->right->rev;
    root->rev = false;
  }
}

void recompute(Node* root) {
  root->sz = root->left->sz + 1 + root->right->sz;
}

p split(Node* root, int k) {
  unreverse(root);
  p ans;
  if (root == emptyNode) {
    ans.first = emptyNode;
    ans.second = emptyNode;
  } else if (root->left->sz >= k) {
    ans.second = root;
    p aux = split(root->left, k);
    ans.first = aux.first;
    ans.second->left = aux.second;
    recompute(ans.second);
  } else {
    ans.first = root;
    p aux = split(root->right, k - root->left->sz - 1);
    ans.second = aux.second;
    ans.first->right = aux.first;
    recompute(ans.first);
  }
  return ans;
}

Node* join(Node* root1, Node* root2) {
  unreverse(root1);
  unreverse(root2);
  if (root1 == emptyNode) {
    return root2;
  }
  if (root2 == emptyNode) {
    return root1;
  }
  if (root1->pr > root2->pr) {
    root1->right = join(root1->right, root2);
    recompute(root1);
    return root1;
  } else {
    root2->left = join(root1, root2->left);
    recompute(root2);
    return root2;
  }
}

int access(Node* root, int k) {
  if (root->left->sz >= k)
    return access(root->left, k);
  if (root->left->sz + 1 == k)
    return root->val;
  return access(root->right, k - root->left->sz - 1);
}

Node* ins(Node* root, int k, int val) {
  Node* nod = new Node{val, 1, rand(), emptyNode, emptyNode, 0};
  p aux = split(root, k - 1);
  return join(join(aux.first, nod), aux.second);
}

Node* del(Node* root, int st, int dr) {
  p aux1 = split(root, st - 1);
  p aux2 = split(aux1.second, dr - st + 1);
  return join(aux1.first, aux2.second);
}

Node* rvrs(Node* root, int st, int dr) {
  p aux1 = split(root, st - 1);
  p aux2 = split(aux1.second, dr - st + 1);
  aux2.first->rev = !aux2.first->rev;
  return join(join(aux1.first, aux2.first), aux2.second);
}

int main() {
  freopen("secv8.in", "r", stdin);
  freopen("secv8.out", "w", stdout);

  srand(time(NULL));

  int n, t;
  scanf("%d%d ", &n, &t);
  Node* root = emptyNode;
  for (int i = 1; i <= n; ++i) {
    char c;
    scanf("%c", &c);
    switch(c) {
      case 'I': {int k, e; scanf("%d%d ", &k, &e); root = ins(root, k, e); break;}
      case 'A': {int k; scanf("%d ", &k); printf("%d\n", access(root, k)); break;}
      case 'R': {int st, dr; scanf("%d%d ", &st, &dr); root = rvrs(root, st, dr); break;}
      case 'D': {int st, dr; scanf("%d%d ", &st, &dr); root = del(root, st, dr); break;}
    }
  }

  for (int i = 1; i <= root->sz; ++i)
    printf("%d ", access(root, i));
  printf("\n");

  return 0;
}