#include <cstdio>
#include <ctime>
#include <algorithm>
using namespace std;
const int BUF_SIZE = 1 << 20;
char buf1[BUF_SIZE];
char buf2[BUF_SIZE];
int poz1 = BUF_SIZE;
int poz2;
char digits[15];
inline char getChar(){
if (poz1 == BUF_SIZE){
fread(buf1, 1, BUF_SIZE, stdin);
poz1 = 0;
}
return buf1[poz1++];
}
inline int read(){
char c;
do{
c = getChar();
} while (!isdigit(c));
int rez = 0;
do{
rez = rez * 10 + c - '0';
c = getChar();
} while (isdigit(c));
return rez;
}
inline void putChar(char c){
buf2[poz2++] = c;
if (poz2 == BUF_SIZE){
fwrite(buf2, 1, BUF_SIZE, stdout);
poz2 = 0;
}
}
inline void write(int x){
int n = 0;
do{
int q = x / 10;
digits[n++] = x - q * 10 + '0';
x = q;
} while(x);
while (n--)
putChar(digits[n]);
}
inline void flush(){
fwrite(buf2, 1, BUF_SIZE, stdout);
}
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;
N = read();
tip = read();
Node* root = emptyNode;
for (int n = 1; n <= N; ++n) {
char c = getChar();
if (c == 'I') {
int k, e;
k = read();
e = read();
root = insert(root, k, e);
} else if (c == 'A') {
int k;
k = read();
write(acces(root, k));
putChar('\n');
} else if (c == 'R') {
int st, dr;
st = read();
dr = read();
root = reverse(root, st, dr);
} else {
int st, dr;
st = read();
dr = read();
root = erase(root, st, dr);
}
}
N = root->sz;
for (int n = 1; n <= N; ++n) {
write(acces(root, n));
putChar(' ');
}
putChar('\n');
flush();
return 0;
}