/**************************************************************

    Problem:

    User: BLADEVIL

    Language: Pascal

    Result: Time_Limit_Exceed

****************************************************************/

//By BLADEVIL

const

    sroot                   =-;

var

    n, m                    :int64;

    a                       :array[-..] of int64;

    root                    :int64;

    father, key, size       :array[-..] of int64;

    son                     :array[-..,..] of int64;

    flag                    :array[-..] of boolean;

    val, sum                :array[-..] of int64;

    pred, succ              :array[-..] of int64;

procedure swap(var a,b:int64);

var

    c                       :int64;

begin

    c:=a; a:=b; b:=c;

end;

function get_max(a,b:int64):int64;

begin

    if a>b then exit(a) else exit(b);

end;

procedure update(x:int64);

begin

    if x=sroot then exit;

    size[x]:=size[son[x,]]+size[son[x,]]+;

    sum[x]:=sum[son[x,]]+sum[son[x,]]+key[x];

    pred[x]:=get_max(pred[son[x,]],sum[son[x,]]+pred[son[x,]]+key[x]);

    succ[x]:=get_max(succ[son[x,]],sum[son[x,]]+succ[son[x,]]+key[x]);

end;

procedure c_renew(x,y:int64);

begin

    key[x]:=y; sum[x]:=size[x]*y;

    pred[x]:=get_max(y,sum[x]);

    succ[x]:=get_max(y,sum[x]);

    val[x]:=y;

end;

procedure r_renew(x:int64);

begin

    swap(son[x,],son[x,]);

    flag[x]:=not flag[x];

end;

procedure push_down(x:int64);

var

    l, r                    :int64;

begin

    l:=son[x,]; r:=son[x,];

    if flag[x] then

    begin

        if l<>- then r_renew(l);

        if r<>- then r_renew(r);

        flag[x]:=false;

    end;

    if val[x]<> then

    begin

        if l<>- then c_renew(l,val[x]);

        if r<>- then c_renew(r,val[x]);

        val[x]:=;

    end;

end;

function build(l,r:int64):int64;

var

    mid                     :int64;

begin

    mid:=(l+r) div ;

    key[mid]:=a[mid];

    build:=mid;

    if mid->=l then

    begin

        son[mid,]:=build(l,mid-);

        father[son[mid,]]:=mid;

    end;

    if mid+<=r then

    begin

        son[mid,]:=build(mid+,r);

        father[son[mid,]]:=mid;

    end;

    update(mid);

end;

procedure rotate(x,y:int64);

var

    f                       :int64;

begin

    push_down(x);

    f:=father[x];

    son[f,y]:=son[x,y xor ];

    father[son[x,y xor ]]:=f;

    if f=root then root:=x else

        if f=son[father[f],] then

            son[father[f],]:=x else

            son[father[f],]:=x;

    father[x]:=father[f];

    father[f]:=x;

    son[x,y xor ]:=f;

    update(f);

    update(x);

end;

procedure splay(x,y:int64);

var

    u, v                    :int64;

begin

    while father[x]<>y do

    if father[father[x]]=y then

        rotate(x,ord(x=son[father[x],]))

    else

    begin

        if x=son[father[x],] then u:= else u:=-;

        if father[x]=son[father[father[x]],] then v:= else v:=-;

        if v*u= then

        begin

            rotate(father[x],ord(x=son[father[x],]));

            rotate(x,ord(x=son[father[x],]));

        end else

        begin

            rotate(x,ord(x=son[father[x],]));

            rotate(x,ord(x=son[father[x],]));

        end;

    end;

    update(x);

end;

function find(k:int64):int64;

var

    t                       :int64;

begin

    t:=root;

    while true do

    begin

        push_down(t);

        if size[son[t,]]+=k then exit(t);

        if size[son[t,]]+>k then t:=son[t,] else

        begin

            dec(k,size[son[t,]]+);

            t:=son[t,];

        end;

    end;

end;

procedure insert;

var

    i                       :longint;

    l, s                    :int64;

    p, q                    :int64;

begin

    read(l,s);

    for i:=n+ to n+s do read(a[i]);

    readln;

    q:=build(n+,n+s);

    n:=n+s;

    p:=find(l+); splay(p,sroot);

    p:=find(l+); splay(p,root);

    p:=son[root,];

    father[q]:=p;

    son[p,]:=q;

    update(p);

    update(root);

end;

procedure delete;

var

    p                       :int64;

    l, s                    :int64;

begin

    readln(l,s);

    p:=find(l); splay(p,sroot);

    p:=find(l+s+); splay(p,root);

    p:=son[son[root,],];

    father[p]:=-;

    son[son[root,],]:=-;

    update(son[root,]);

    update(root);

end;

procedure change;

var

    l, s, c                 :int64;

    p                       :int64;

begin

    readln(l,s,c);

    p:=find(l); splay(p,sroot);

    p:=find(l+s+); splay(p,root);

    p:=son[son[root,],];

    c_renew(p,c);

    update(son[root,]);

    update(root);

end;

procedure reverse;

var

    p                       :int64;

    l, s                    :int64;

begin

    readln(l,s);

    p:=find(l); splay(p,sroot);

    p:=find(l+s+); splay(p,root);

    p:=son[son[root,],];

    r_renew(p);

    //update(son[root,]);

    //update(root);

end;

procedure get_sum;

var

    l, s                    :int64;

    p                       :int64;

begin

    readln(l,s);

    p:=find(l); splay(p,sroot);

    p:=find(l+s+); splay(p,root);

    p:=son[son[root,],];

    writeln(sum[p]);

end;

procedure max_sum;

var

    l, r                    :int64;

begin

    readln;

    l:=son[root,]; r:=son[root,];

    writeln(get_max(succ[l]+pred[r]+key[root],get_max(pred[l],succ[r])));

end;

procedure main;

var

    i                       :longint;

    ss                      :ansistring;

    ch                      :char;

begin

    fillchar(son,sizeof(son),);

    read(n,m);

    for i:= to n do read(a[i]);

    inc(n);

    root:=build(,n);

    father[root]:=sroot;

    readln;

    for i:= to m do

    begin

        read(ch);

        ss:='';

        while ch<>' ' do

        begin

            ss:=ss+ch;

            read(ch);

            if ss='MAX-SUM' then break;

        end;

        if ss='INSERT' then insert else

        if ss='DELETE' then delete else

        if ss='MAKE-SAME' then change else

        if ss='REVERSE' then reverse else

        if ss='GET-SUM' then get_sum else

        if ss='MAX-SUM' then max_sum;

    end;

end;

begin

    main;

end.