#include <iostream>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 #include<stdlib.h>

 #include<vector>

 #include<cmath>

 #include<queue>

 #include<set>

 using namespace std;

 #define N 300010

 #define LL long long

 #define INF 0xfffffff

 #define key_value ch[ch[root][1]][0]

 const double eps = 1e-;

 const double pi = acos(-1.0);

 const double inf = ~0u>>;

 using namespace std;

 struct splay_tree

 {

     int pre[N],size[N];

     int ch[N][];

     int root,tot,num,tot1;

     int key[N],lz[N];

     void dfs(int x)

     {

         if(x)

         {

             dfs(ch[x][]);

             printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size=%2d,key=%2d lz = %d\n",

                    x,ch[x][],ch[x][],pre[x],size[x],key[x],lz[x]);

             dfs(ch[x][]);

         }

     }

     void debug()

     {

         printf("root:%d\n",root);

         dfs(root);

     }

 //以上用于debug*/

     void newnode(int &x,int v,int fa)//新建一结点

     {

         x = ++tot;

         ch[x][]=ch[x][] = ;

         pre[x] = fa;

         lz[x] = ;

         size[x] = ;

         key[x] = v;

     }

     void pushdown(int w)

     {

         if(lz[w])

         {

             int l = ch[w][],r = ch[w][];

             swap(ch[w][],ch[w][]);

             lz[l]^=lz[w];

             lz[r]^=lz[w];

             lz[w] = ;

         }

     }

     void pushup(int w)//由儿子更新其父亲

     {

         size[w] = size[ch[w][]]+size[ch[w][]]+;

         //cout<<s[w][0]<<" "<<s[w][1]<<endl;

     }

     void rotate(int r,int kind)//旋转操作，根据kind进行左旋和右旋

     {

         int y = pre[r];

         pushdown(y);

         pushdown(r);

         ch[y][!kind] = ch[r][kind];

         pre[ch[r][kind]] = y;

         if(pre[y])

         {

             ch[pre[y]][ch[pre[y]][]==y] = r;

         }

         pre[r] = pre[y];

         ch[r][kind] = y;

         pre[y] = r;

         pushup(y);

         pushup(r);

     }

     void splay(int r,int goal)//将r结点旋至goal下

     {

         pushdown(r);

         while(pre[r]!=goal)

         {

             if(pre[pre[r]]==goal)

             {

                 rotate(r,ch[pre[r]][]==r);

             }

             else

             {

                 int y = pre[r];

                 int kind = (ch[pre[y]][]==y);

                 if(ch[y][kind]==r)

                 {

                     rotate(r,!kind);

                     rotate(r,kind);

                 }

                 else

                 {

                     rotate(y,kind);

                     rotate(r,kind);

                 }

             }

         }

         pushup(r);

         if(goal==) root = r;

     }

     int get_k(int k)//得到第k个的结点

     {

         int r = root;

        pushdown(r);

         while(size[ch[r][]]+!=k)

         {

             if(size[ch[r][]]>=k)

                 r = ch[r][];

             else

             {

                 k-=(size[ch[r][]]+);//根据左右结点的数量来确定第k个节点在哪里

                 r = ch[r][];

             }

             pushdown(r);

         }

         pushup(r);

         return r;

     }

     void cut(int l,int r,int k)

     {

         splay(get_k(l),);

         splay(get_k(r+),root);

         pushdown(ch[root][]);

         int nod = key_value;

         ch[ch[root][]][] = ;

         pre[nod] = ;

         pushup(ch[root][]);

         pushup(root);

         //debug();

         splay(get_k(k),);

         splay(get_k(k+),root);

         ch[ch[root][]][] = nod;

         pre[nod] = ch[root][];

         pushup(ch[root][]);

         pushup(root);

        // debug();

     }

     void filp(int l,int r)

     {

         //cout<<get_k(l)<<" "<<get_k(r+2)<<endl;

         splay(get_k(l),);

         splay(get_k(r+),root); //cout<<","<<endl;debug();

         lz[key_value]^=;

         //swap(ch[key_value][0],ch[key_value][1]);

         pushup(ch[root][]);

         pushup(root);

     }

     void work(int n)

     {

         int i;

         for(i =  ;i < n ;i++)

         {

             printf("%d ",key[get_k(i+)]);

         }

         printf("%d\n",key[get_k(n+)]);

         //debug();

     }

     void build(int &x,int l,int r,int fa)

     {

         int m = (l+r)>>;

         if(l>r) return ;

         newnode(x,m,fa);

         build(ch[x][],l,m-,x);

         build(ch[x][],m+,r,x);

         pushup(x);

     }

     void init(int o)

     {

         size[] = ch[][] = ch[][] =  key[] = lz[] = ;

         root = tot = ;

         newnode(root,,);

         newnode(ch[root][],,root);

         build(ch[ch[root][]][],,o,ch[root][]);

         size[root] = ;

         pushup(ch[root][]);

         pushup(root);

     }

 }SP;

 int main()

 {

     int n,q;

     while(scanf("%d%d",&n,&q)!=EOF)

     {

         if(n==-&&q==-) break;

         SP.init(n);

         while(q--)

         {

             char sq[];

             int k,x,y;

             scanf("%s",sq);

             if(sq[]=='C')

             {

                 scanf("%d%d%d",&x,&y,&k);

                 SP.cut(x,y,k+);

               // SP.debug();

 //                SP.work(n);

             }

             else

             {

                 //SP.debug();

                 scanf("%d%d",&x,&y);

                 SP.filp(x,y);

                 //SP.debug();

             }

             //SP.work(n);

         }

         SP.work(n);

     }

     return ;

 }