网上有许多题，就是给定一个序列，要你支持几种操作：A、B、C、D。一看另一道题，又是一个序列 要支持几种操作：D、C、B、A。尤其是我们这里的某人，出模拟试题，居然还出了一道这样的，真是没技术含量……这样 我也出一道题，我出这一道的目的是为了让大家以后做这种题目有一个“库”可以依靠，没有什么其他的意思。这道题目 就叫序列终结者吧。

【问题描述】 给定一个长度为N的序列，每个序列的元素是一个整数（废话）。要支持以下三种操作： 1. 将[L,R]这个区间内的所有数加上V。 2. 将[L,R]这个区间翻转，比如1 2 3 4变成4 3 2 1。 3. 求[L,R]这个区间中的最大值。 最开始所有元素都是0。

第一行两个整数N，M。M为操作个数。 以下M行，每行最多四个整数，依次为K，L，R，V。K表示是第几种操作，如果不是第1种操作则K后面只有两个数。

对于每个第3种操作，给出正确的回答。

4 4
1 1 3 2
1 2 4 -1
2 1 3
3 2 4

2
【数据范围】
N<=50000，M<=100000。

 #include<cstdio>

 #include<cstring>

 #include<iostream>

 using namespace std;

 const int maxn = +;

 const int INF = 1e9;

 inline int read() {

     char c=getchar();

     while(!isdigit(c)) c=getchar();

     int x=;

     while(isdigit(c)) {

         x=x*+c-'';

         c=getchar();

     }

     return x;

 }

 struct Node {

     Node* ch[];

     int v,s,flip,addv,maxv;

     int cmp(int k) const {

         int d=k - ch[]->s;

         if(d==) return -;

         return d<=? :;

     }

     void pushdown() {

         if(addv) {

             v+=addv;

             ch[]->addv+=addv,ch[]->addv+=addv;

             addv=;

         }

         if(flip) {

             flip=;  swap(ch[],ch[]);  ch[]->flip^=,ch[]->flip^=;

         }

     }

     void maintain() {

         s=ch[]->s+ch[]->s+;

         maxv=max(ch[]->v,ch[]->v),maxv=max(maxv,v);

     }

 };

 Node* null=new Node();

 void rotate(Node* &o,int d) {

     Node* k=o->ch[d^]; o->ch[d^]=k->ch[d],k->ch[d]=o;

     o->maintain(),k->maintain(); o=k;

 }

 void splay(Node* &o,int k) {    //splay 的同时pushdown 下传标记

     o->pushdown();

     int d=o->cmp(k);

     if(d==) k-=o->ch[]->s+;

     if(d!=-) {

         Node* p=o->ch[d];

         p->pushdown();

         int d2=p->cmp(k);

         int k2=d2==? k-p->ch[]->s-:k;

         if(d2!=-) {

             splay(p->ch[d2],k2);

             if(d==d2) rotate(o,d^);  else rotate(o->ch[d],d);

         }

         rotate(o,d^);

     }

 }

 Node* merge(Node* left,Node* right) {

     splay(left,left->s);

     left->ch[]=right,left->maintain();

     return left;

 }

 void split(Node* o,int k,Node* &left,Node* &right) {

     splay(o,k);

     left=o,right=left->ch[],left->ch[]=null,left->maintain();

 }

 struct SplaySeq {

     int n;

     Node *root,seq[maxn];

     Node* build(int sz) {

         if(!sz) return null;

         Node* l=build(sz/);

         Node* o=&seq[++n];

         o->v=,o->maxv=-INF;

         o->ch[]=l,o->ch[]=build(sz-sz/-);

         o->flip=o->s=;

         o->maintain();

         return o;

     }

     void init(int sz) {

         n=null->s=null->addv=;

         null->v=null->maxv=-INF;

         root=build(sz);

     }

 }ss;

 int n,m;

 int main() {

     n=read(),m=read();

     ss.init(n+);

     int k,l,r,v;

     Node *left,*right,*mid;

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

         k=read(),l=read(),r=read();

         split(ss.root,l,left,right),split(right,r-l+,mid,right);

         switch(k) {

             case :

                 v=read(); mid->addv+=v;

                 break;

             case :

                 mid->flip^=;

                 break;

             case :

                 printf("%d\n",mid->maxv);

                 break;

         }

         ss.root = merge(merge(left,mid),right);

     }

     return ;

 }