#include <bits/stdc++.h>

 #define pii pair<int,int>

 #define INF 0x3f7f7f7f

 #define LL long long

 using namespace std;

 const int N=;

 const int mod=;

 struct node

 {

     int key, pre, flip, ch[], son[];

 }nod[N];

 int  n, m, a, b, node_cnt, root;

 int create_node(int v,int far)

 {

     nod[node_cnt].key=v;

     nod[node_cnt].pre=far;

     nod[node_cnt].flip=;

     nod[node_cnt].ch[]=;

     nod[node_cnt].ch[]=;

     nod[node_cnt].son[]=;

     nod[node_cnt].son[]=;

     return node_cnt++;

 }

 void push_down(int t)

 {

     if(nod[t].flip)

     {

         swap(nod[t].ch[],  nod[t].ch[]);

         swap(nod[t].son[], nod[t].son[]);

         nod[t].flip=;

         int L=nod[t].ch[], R=nod[t].ch[];

         if(L)   nod[L].flip=!nod[L].flip;

         if(R)   nod[R].flip=!nod[R].flip;

     }

 }

 void Rotate(int t,int d)

 {

     int son=nod[t].ch[d];

     int far=nod[t].pre;

     int gra=nod[far].pre;

     nod[son].pre=far;

     nod[far].pre=t;

     nod[t].pre=gra;

     nod[t].ch[d]=far;

     nod[far].ch[d^]=son;

     nod[gra].ch[ nod[gra].ch[]==far ]=t;

     nod[far].son[d^]=nod[t].son[d];

     nod[t].son[d]+=nod[far].son[d]+;

 }

 int Insert(int t,int v)

 {

     if(t==)    return root=create_node(v, );

     if( v<nod[t].key )

     {

         if(nod[t].ch[])    return Insert(nod[t].ch[], v);

         else                return nod[t].ch[]=create_node(v, t);

     }

     else

     {

         if(nod[t].ch[])    return Insert(nod[t].ch[], v);

         else                return nod[t].ch[]=create_node(v, t);

     }

 }

 void Splay(int t,int goal)

 {

     while(nod[t].pre!=goal)

     {

         int f=nod[t].pre, g=nod[f].pre;

         if(g==goal)    Rotate(t, nod[f].ch[]==t);

         else

         {

             int d1=nod[f].ch[]==t, d2=nod[g].ch[]==f;

             if(d1==d2)  Rotate(f, d1),Rotate(t, d1);

             else        Rotate(t, d1),Rotate(t, d2);

         }

     }

     if(!goal)   root=t;

 }

 int Find(int t,int k)   //找第k个元素，必须能找到。这里不处理出错。

 {

     push_down(t);               //找的时候顺便往下推。

     if( nod[t].son[]+==k )    return t;

     if( k<nod[t].son[]+ )     return Find(nod[t].ch[], k);

     else    return Find(nod[t].ch[], k-nod[t].son[]-);

 }

 void Split(int t, int k, int &L, int &R)    //在以t为根的树中将[1,k]分离出来，变成两棵树L和R。

 {

     Splay( Find(t, k), );   //查找第k个元素，并伸展到根

     L=root;

     R=nod[L].ch[];

     nod[L].son[]=;

     nod[L].ch[]=;

     nod[R].pre=;

 }

 int Merge(int L,int R)

 {

     int k=nod[L].son[]+nod[L].son[]+;

     Splay( Find(L, k),  );         //在用Splay时，必须先往下推。

     L=root;

     nod[L].ch[]=R;

     nod[R].pre=L;

     nod[L].son[]=nod[R].son[]++nod[R].son[];

     return L;

 }

 void cal(int a,int b)   //从树中取出[a,b]然后旋转，插到尾部

 {

     int left=, mid=, right=;

     if(a!= && b!=n)    //三段

     {

         Split(root,  a-, left, right);

         Split(right, b-a+, mid, right );

         nod[mid].flip^=;

         root=Merge(Merge( left, right ) , mid );

     }

     else if(a==)       //中后段

     {

         Split(root, b, mid, right );

         nod[mid].flip^=;

         root=Merge( right, mid );

     }

     else if(b==n)       //前中段

     {

         Split(root, a-, left, mid);

         nod[mid].flip^=;

         root=Merge(left, mid );

     }

 }

 void print(int t)    //深搜输出

 {

     push_down(t);   //要往下推

     if(nod[t].ch[])    print(nod[t].ch[]);

     printf("%d\n", nod[t].key);

     if(nod[t].ch[])    print(nod[t].ch[]);

 }

 int main()

 {

     //freopen("input.txt", "r", stdin);

     node_cnt=;root=;

     cin>>n>>m;

     for(int i=; i<=n; i++)    Splay(Insert(root, i), );

     for(int i=; i<m; i++)

     {

         scanf("%d%d",&a,&b);

         if(a== && b==n)  nod[root].flip^=;    //整个区间都翻转

         cal(a,b);

     }

     print(root);

     return ;

 }