#include <bits/stdc++.h>

using namespace std;

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

struct Node {
    int val, priority, size;
    bool lazy;
    Node *left, *right;

    Node(int val) {
        this->val = val;
        priority = rand();
        size = 1;
        lazy = false;
        left = right = NULL;
    }
};

int q, rev;
Node *root;

int getSize(Node *node) {
    if (node == NULL)
        return 0;

    return node->size;
}

void update(Node *node) {
    if (node == NULL)
        return;

    node->size = 1 + getSize(node->left) + getSize(node->right);
}

void push(Node *node) {
    if (node == NULL || node->lazy == false)
        return;

    swap(node->left, node->right);

    if (node->left != NULL)
        node->left->lazy ^= 1;

    if (node->right != NULL)
        node->right->lazy ^= 1;

    node->lazy = false;
}

void split(Node *node, Node *&left, Node *&right, int k) {
    if (node == NULL) {
        left = right = NULL;
        return;
    }

    push(node);

    if (getSize(node->left) >= k) {
        split(node->left, left, node->left, k);
        right = node;
        update(right);
    } else {
        split(node->right, node->right, right, k - getSize(node->left) - 1);
        left = node;
        update(left);
    }
}

void merge(Node *&node, Node *left, Node *right) {
    push(left);
    push(right);

    if (left == NULL) {
        node = right;
        return;
    }

    if (right == NULL) {
        node = left;
        return;
    }

    if (left->priority > right->priority) {
        merge(left->right, left->right, right);
        node = left;
    } else {
        merge(right->left, left, right->left);
        node = right;
    }

    update(node);
}

void insertValue(int pos, int val) {
    Node *a, *b, *node;

    node = new Node(val);

    split(root, a, b, pos - 1);
    merge(a, a, node);
    merge(root, a, b);
}

int accessValue(Node *node, int pos) {
    push(node);

    int leftSize = getSize(node->left);

    if (pos == leftSize + 1)
        return node->val;

    if (pos <= leftSize)
        return accessValue(node->left, pos);

    return accessValue(node->right, pos - leftSize - 1);
}

void reverseInterval(int l, int r) {
    Node *a, *b, *c;

    split(root, a, b, l - 1);
    split(b, b, c, r - l + 1);

    if (b != NULL)
        b->lazy ^= 1;

    merge(b, b, c);
    merge(root, a, b);
}

void deleteInterval(int l, int r) {
    Node *a, *b, *c;

    split(root, a, b, l - 1);
    split(b, b, c, r - l + 1);

    merge(root, a, c);
}

void print(Node *node) {
    if (node == NULL)
        return;

    push(node);

    print(node->left);
    fout << node->val << " ";
    print(node->right);
}

int main() {
    fin >> q >> rev;

    srand(1234567);

    for (int i = 1; i <= q; ++i) {
        char type;
        fin >> type;

        if (type == 'I') {
            int k, e;
            fin >> k >> e;

            insertValue(k, e);
        }

        if (type == 'A') {
            int k;
            fin >> k;

            fout << accessValue(root, k) << "\n";
        }

        if (type == 'R') {
            int l, r;
            fin >> l >> r;

            reverseInterval(l, r);
        }

        if (type == 'D') {
            int l, r;
            fin >> l >> r;

            deleteInterval(l, r);
        }
    }

    print(root);

    return 0;
}