#include <bits/stdc++.h>
using namespace std;
#include <fstream>

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

struct Treap_node{
    int key, priority;
    int nr_nodes;
    bool rev;
    Treap_node *left, *right;
};

Treap_node* emptyNode = new Treap_node{-1, -1, 0, false, nullptr, nullptr};
Treap_node* root = emptyNode;
using pt = pair<Treap_node *, Treap_node *>;

void push(Treap_node* my_node) {
    if(my_node!=emptyNode && my_node->rev) {
        swap(my_node->left, my_node->right);
        my_node->left->rev ^= 1;
        my_node->right->rev ^= 1;
        my_node->rev = 0;
    }
}
int get_size(Treap_node *my_node) {
    return my_node!=emptyNode ? my_node->nr_nodes : 0;
}

void update_size(Treap_node *my_node) {
    if(my_node!=emptyNode)
        my_node->nr_nodes =  1 + get_size(my_node->left) + get_size(my_node->right);
}

pt split(Treap_node *node, int k) {
    if(node==emptyNode)
        return {emptyNode, emptyNode};
    push(node);

    // printf("%d @@\n", node->left->nr_nodes);
    if(node->left->nr_nodes >= k) {
        pt p = split(node->left, k);

        node->left = p.second;
        update_size(node);
        return {p.first, node};
    }
    else {
        pt p = split(node->right, k - node->left->nr_nodes -1);

        node->right = p.first;
        update_size(node);
        return {node, p.second};
    }
}

Treap_node* merge(Treap_node *A, Treap_node *B) {
    if(A==emptyNode)
        return B;
    if(B==emptyNode)
        return A;
    
    push(A);
    push(B);

    if(B->priority < A->priority) {
        A->right = merge(A->right, B);
        update_size(A);
        return A;
    }

    B->left = merge(A, B->left);
    update_size(B);
    return B;
}

Treap_node* ins(Treap_node *nod, int k, Treap_node* new_node) {
    pt p = split(nod, k-1);
    // printf("HERE\n");
    return merge(merge(p.first, new_node), p.second);
}

Treap_node* rev(Treap_node *nod, int st, int dr) {
    pt p1 = split(nod, st - 1);
    pt p2 = split(p1.second, dr - st + 1);
    p2.first->rev ^= 1;

    return merge(merge(p1.first, p2.first), p2.second);
}

Treap_node* rem(Treap_node *nod, int st ,int dr) {
    pt p1 = split(nod, st - 1);
    pt p2 = split(p1.second, dr - st + 1);

    return merge(p1.first, p2.second);
}

int getElement(Treap_node* nod, int k) {
    push(nod);
    int leftSize = get_size(nod->left);
    if(k == leftSize + 1)
        return nod->key;
    else if(k<=leftSize)
        return getElement(nod->left, k);
    else {
        return getElement(nod->right, k - nod->left->nr_nodes - 1);
    }
}

void inOrder(Treap_node* nod) {
    if(nod==emptyNode)
        return;
    push(nod);
    inOrder(nod->left);
    fout<<nod->key<<" ";
    inOrder(nod->right);
}

void solveQuery(int i) {
    char op;
    fin>>op;
    if(op == 'A') {
        int k;
        fin >> k;
        fout << getElement(root, k) << '\n';
        return;
    }
    else if(op == 'I') {
        int k, x;
        fin >> k >> x;
        root = ins(root, k, new Treap_node{x, rand(), 1, false, emptyNode, emptyNode});
        return;
    }
    else if(op == 'R') {
        int st, dr;
        fin >> st >>dr;
        root = rev(root, st, dr);
        return;
    }
    int st, dr;
    fin >> st >>dr;
    root = rem(root, st, dr);
}

void TestCase() {
    int q, ok_rev;
    fin>>q >> ok_rev;
    for(int i = 1; i <= q; i++) {
        // printf("%d\n", i);s
        solveQuery(i);
    }
    inOrder(root);
    fout<<'\n';
}
int main() {
    int tests = 1;
    // fin>>tests;
    for(int i = 1; i <= tests; i++) {
        TestCase();
    }
    fin.close();
    fout.close();
    return 0;
}