#include <fstream>
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <cmath>
#include <climits>

std::ifstream in ( "secv8.in"  );
std::ofstream out( "secv8.out" );

struct T {
    int key, pr, sz;
    T *ln, *rn; bool rv;
    T() {
        this -> key = this -> pr = this -> sz = 0;
        this -> ln = this -> rn = NULL; this -> rv = false; }
    T( int key, int pr, T *ln, T *rn ) {
        this -> key = key; this -> pr = pr; this -> sz = 1;
        this -> ln = ln; this -> rn = rn; this -> rv = false; }
} *rot, *nil;

T* update( T *tr ) {
    if( tr == nil ) { return tr; }
    if( tr -> rv == true ) {
        tr -> rv = false; std::swap( tr -> ln, tr -> rn );
        if( tr -> ln != nil ) { tr -> ln -> rv ^= true; }
        if( tr -> rn != nil ) { tr -> rn -> rv ^= true; } }
    tr -> sz = 1 + tr -> ln -> sz + tr -> rn -> sz;
    return tr; }

std::pair<T*, T*> split( T *tr, int pos ) {
    tr = update( tr ); std::pair<T*, T*> ans;
    if( tr == nil ) { return std::make_pair(nil, nil); }
    if( tr -> ln -> sz + 1 > pos ) {
        ans = split( tr -> ln, pos );
        tr -> ln = ans.second; ans.second = tr; }
    else {
        ans = split( tr -> rn, pos - (tr -> ln -> sz + 1) );
        tr -> rn = ans.first; ans.first = tr; }
    tr = update( tr ); return ans; }

T* join( T *trl, T *trr ) {
    trl = update( trl ); trr = update( trr );
    if( trl == nil ) { return trr; }
    if( trr == nil ) { return trl; }
    if( trl -> pr > trr -> pr ) {
        trl -> rn = join( trl -> rn, trr );
        trl = update( trl ); return trl; }
    else {
        trr -> ln = join( trl, trr -> ln );
        trr = update( trr ); return trr; }
    return nil; }

T* insert( T *tr, int pos, int key ) {
    std::pair<T*, T*> aux = split( tr, pos - 1 );
    tr = new T( key, std::abs( rand() ) % INT_MAX, aux.first, aux.second );
    tr = update( tr ); return tr; }

T* erase( T *tr, int pos1, int pos2 ) {
    std::pair<T*, T*> aux1, aux2;
    aux2 = split( tr, pos2 ); aux1 = split( aux2.first, pos1 - 1 );
    tr = join( aux1.first, aux2.second ); return tr; }

T* access( T *tr, int pos ) {
    std::pair<T*, T*> aux1, aux2;
    aux2 = split( tr, pos ); aux1 = split( aux2.first, pos - 1 );
    out << aux1.second -> key << "\n"; aux2.first = join( aux1.first, aux1.second );
    tr = join( aux2.first, aux2.second ); return tr; }

T* reverse( T *tr, int pos1, int pos2 ) {
    std::pair<T*, T*> aux1, aux2;
    aux2 = split( tr, pos2 ); aux1 = split( aux2.first, pos1 - 1 );
    aux1.second -> rv = true; aux2.first = join( aux1.first, aux1.second );
    tr = join( aux2.first, aux2.second ); return tr; }

void dump( T *tr ) {
    tr = update( tr );
    if( tr == nil ) {
        return; }
    dump( tr -> ln );
    out << tr -> key << " ";
    dump( tr -> rn );
    return; }

int main( int argc, const char *argv[] ) {
    std::ios::sync_with_stdio( false ); srand( time(0) );
    rot = nil = new T; rot -> ln = rot -> rn = nil;
    int n, h; in >> n >> h;
    for( int i = 1; i <= n; i ++ ) {
        char ch; in >> ch;
        switch( ch ) {
            case 'I': {
                int k, e; in >> k >> e;
                rot = insert( rot, k, e );
                break; }
            case 'A': {
                int k; in >> k;
                rot = access( rot, k );
                break; }
            case 'R': {
                int p, q; in >> p >> q;
                rot = reverse( rot, p, q );
                break; }
            case 'D': {
                int p, q; in >> p >> q;
                rot = erase( rot, p, q );
                break; } } }
    dump( rot ); out << "\n";
    return 0; }