#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

#define MAX_BUCK 512
#define MAX_NR 500000

struct Bucket {
   bool bReverse;
   int *a, nrElem;
   
   Bucket() {
      bReverse = false;
      nrElem = 0;
      a = new int[MAX_BUCK];
   }

   ~Bucket() {
      delete []a;
   }

   void clear() {
      nrElem = 0;
      bReverse = false;
   }

   int getPoz(int k) {
      if (!bReverse) {
         return k;
      } else {
         return nrElem - k - 1;
      }
   }

   void reversePartial(int st, int fn) {
      st = getPoz(st);
      fn = getPoz(fn);
      if (st > fn) {
         swap(st, fn);
      }
      reverse(a + st, a + fn + 1);
   }

   int deleteRange(int st, int fn) {
      st = getPoz(st);
      fn = getPoz(fn);
      if (st > fn) {
         swap(st, fn);
      }
      memmove(a + st, a + fn + 1, sizeof(int) * (nrElem - fn));
      nrElem -= (fn - st + 1);
      return fn - st + 1;
   }

   int getElem(int k) {
      return a[getPoz(k)];
   }

   void insert(int poz, int val) {
      poz = getPoz(poz);
      if (bReverse) {
         poz++;
      }
      nrElem++;
      memmove(a + poz + 1, a + poz, sizeof(int) * (nrElem - poz));
      a[poz] = val;
   }

   void print() {
      if (!bReverse) {
         for (int i = 0; i < nrElem; i++) {
            printf("%d ", a[i]);
         }
      } else {
         for (int i = nrElem - 1; i >= 0; i--) {
            printf("%d ", a[i]);
         }
      }
   }

   void mergeWith(Bucket &b) {
      if (bReverse) {
         bReverse = false;
         reverse(a, a + nrElem);
      }
      memcpy(a + nrElem, b.a, sizeof(int) * b.nrElem);
      if (b.bReverse) {
         reverse(a + nrElem, a + nrElem + b.nrElem);
      }
      nrElem += b.nrElem;
   }
};

int nrBuckets = 1;
Bucket buckets[MAX_NR / MAX_BUCK], bTemp;

int getBucket(int &poz) {
   int b = 0;
   while (b + 1 < nrBuckets && buckets[b].nrElem < poz) {
      poz -= buckets[b++].nrElem;
   }
   return b;
}

void insertBucket(int poz, Bucket &bTemp) {
   memmove(buckets + poz + 1, buckets + poz, sizeof(Bucket) * (nrBuckets - poz));
   buckets[poz] = bTemp;
   nrBuckets++;
}

int GetElement(int poz) {
   int b = getBucket(poz);
   return buckets[b].getElem(poz);
}

void InsertElem(int poz, int val) {
   int b = getBucket(poz);
   if (buckets[b].nrElem < MAX_BUCK) {
      buckets[b].insert(poz, val);
   } else {
      insertBucket(b + 1, buckets[nrBuckets]);
      buckets[b + 1].insert(0, val);
   }
}

void DeleteRange(int st, int fn) {
   int bFirst = getBucket(st);
   int bLast = getBucket(fn);
   if (bFirst == bLast) {
      buckets[bFirst].deleteRange(st, fn);
      return;
   }
   buckets[bFirst].deleteRange(st, buckets[bFirst].nrElem);
   for (int b = bFirst + 1; b < bLast; b++) {
      buckets[b].clear();
   }
   buckets[bLast].deleteRange(0, fn);
}

void ReverseRange(int st, int fn) {
   int bFirst = getBucket(st);
   int bLast = getBucket(fn);
   
   if (bFirst == bLast) {
      buckets[bFirst].reversePartial(st, fn);
      return;
   }
   //buckets[bFirst].reset();
   //buckets[bLast].reset();
   //if (bFirst > 0 && st + buckets[bFirst - 1].nrElem <= MAX_BUCK) {
   //} else {
   //}
}

int main() {
   freopen("secv8.in", "rb", stdin);
   freopen("secv8.out", "wb", stdout);
   int M, ignore;
   scanf("%d %d\n", &M, &ignore);
   while (M--) {
      char op;
      int st, fn, poz, val;
      scanf("%c", &op);
      if (op == 'A') {
         scanf("%d\n", &poz);
         printf("%d\n", GetElement(poz - 1));
      } else
      if (op == 'I') {
         scanf("%d %d\n", &poz, &val);
         InsertElem(poz - 1, val);
      } else {
         scanf("%d %d\n", &st, &fn);
         st--; fn--;
         if (op == 'D') {
            DeleteRange(st, fn);
         } else {
            ReverseRange(st, fn);
         }
      }
   }
   for (int i = 0; i < nrBuckets; i++) {
      buckets[i].print();
   }
   return 0;
}