#include <cstdio>
#include <algorithm>

struct Node {
 bool reversed;
 int val;
 int size;
 Node* left;
 Node* right;
};

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

void unreverse(Node* root) {
 if (root != emptyNode && root->reversed) {
   std::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->size = root->left->size + 1 + root->right->size;
}

std::pair<Node*, Node*> split(Node* root, int k) {
 unreverse(root);
 std::pair<Node*, Node*> answer;
 if (root == emptyNode) {
   answer.first = emptyNode;
   answer.second = emptyNode;
 } else if (k <= root->left->size) {
   answer.second = root;
   auto p = split(root->left, k);
   answer.first = p.first;
   recompute(answer.second);
   answer.second->left = p.second;
 } else {
   answer.first = root;
   auto p = split(root->right, k - root->left->size - 1);
   answer.first->right = p.first;
   recompute(answer.first);
   answer.second = p.second;
 }
 return answer;
}

Node* join(Node* root1, Node* root2) {
 unreverse(root1);
 unreverse(root2);
 if (root1 == emptyNode) {
   return root2;
 } else if (root2 == emptyNode) {
   return root1;
 } else if (root1->size > root2->size) {
   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) {
 unreverse(root);
 if (root->left->size >= k) {
   return access(root->left, k);
 } else if (root->left->size + 1 == k) {
   return root->val;
 } else {
   return access(root->right, k - root->left->size - 1);
 }
}

Node* insert(Node* root, int k, Node* val) {
 auto p = split(root, k - 1);
 return join(join(p.first, val), p.second);
}

Node* insert(Node* root, int k, int val) {
 return insert(root, k, new Node{false, val, 1, emptyNode, emptyNode});
}

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

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

Node* reverse(Node* root, int i, int j) {
 auto p1 = split(root, i - 1);
 auto p2 = split(p1.second, j - i + 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);

 int N, tip;

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

 Node* root = emptyNode;

 for (int n = 1; n <= N; ++n){
    getc(stdin);
    char c;
    c = getc(stdin);
    switch (c){
     case 'I': {int k, e; scanf("%d%d", &k, &e); root = insert(root, k ,e); break;}
     case 'A': {int k; scanf("%d", &k); printf("%d\n", access(root, k)); break;}
     case 'R': {int i, j; scanf("%d%d", &i, &j); root = reverse(root, i, j); break;}
     case 'D': {int i, j; scanf("%d%d", &i, &j); root = erase(root, i, j); break;}
    }
 }

 N = root->size;

 for (int n = 1; n <= N; ++n)
    printf("%d ", access(root, n));

 printf("\n");

 return 0;
}