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

using namespace std;

struct Node {
  int val;
  int sz;
  long long priority;
  Node* left;
  Node* right;
  bool reversed;
};

struct Answer {
  Node* first;
  Node* second;
};

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

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

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

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

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

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

Node* insert(Node* root, int k, int val) {
  Node* newNode = new Node{val, 1, ((long long)rand() << 31) ^ rand(), emptyNode, emptyNode, false};
  auto aux = split(root, k - 1);
  return join(join(aux.first, newNode), aux.second);
}

Node* erase(Node* root, int st, int dr) {
  auto p1 = split(root, st - 1);
  auto p2 = split(p1.second, dr - st + 1);
  delete p2.first;
  return join(p1.first, p2.second);
}

Node* reverse(Node* root, int st, int dr) {
  auto p1 = split(root, st - 1);
  auto p2 = split(p1.second, dr - st + 1);
  p2.first->reversed = !p2.first->reversed;
  return join(join(p1.first, p2.first), p2.second);
}

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

  srand(time(NULL));

  int N, tip;

  scanf("%d%d ", &N, &tip);

  Node* root = emptyNode;

  for (int n = 1; n <= N; ++n) {
    char c = getc(stdin);
    if (c == 'I') {
      int k, e;
      scanf("%d%d ", &k, &e);
      root = insert(root, k, e);
    } else if (c == 'A') {
      int k;
      scanf("%d ", &k);
      printf("%d\n", acces(root, k));
    } else if (c == 'R') {
      int st, dr;
      scanf("%d%d ", &st, &dr);
      root = reverse(root, st, dr);
    } else {
      int st, dr;
      scanf("%d%d ", &st, &dr);
      root = erase(root, st, dr);
    }
  }

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

  return 0;
}