#include<bits/stdc++.h>
#define lc tr[p].son[0]
#define rc tr[p].son[1]
using namespace std;

const int MAXN=5e5+10;
const int INF=0x3f3f3f3f;

struct Node{
    int son[2];
    int val,pri,siz;
    int sum,pres,sufs,maxs;
    int cov;
    bool rev;
}tr[MAXN];

int rt,idx;
stack<int> mem_pool;
int n,m;

int new_node(int v=0){
    static int cnt=0;
    int p;
    if(!mem_pool.empty()){
        p=mem_pool.top();
        mem_pool.pop();
    }else{
        p=++idx;
    }
    tr[p].pri=rand();
    tr[p].siz=1;
    tr[p].val=tr[p].sum=tr[p].maxs=v;
    tr[p].pres=tr[p].sufs=max(0,v);
    tr[p].rev=false;
    tr[p].cov=INF;
    lc=rc=0;
    return p;
}

void build(int &p,int l,int r,int a[]){
    if(l>r) return;
    int mid=(l+r)>>1;
    p=new_node(a[mid]);
    build(lc,l,mid-1,a);
    build(rc,mid+1,r,a);
    tr[p].siz=tr[lc].siz+tr[rc].siz+1;
    tr[p].sum=tr[lc].sum+tr[p].val+tr[rc].sum;
    tr[p].pres=max(tr[lc].pres,tr[lc].sum+tr[p].val+tr[rc].pres);
    tr[p].sufs=max(tr[rc].sufs,tr[rc].sum+tr[p].val+tr[lc].sufs);
    tr[p].maxs=max(max(tr[lc].maxs,tr[rc].maxs),tr[lc].sufs+tr[p].val+tr[rc].pres);
}

void up(int p){
    if(!p) return;
    tr[p].siz=tr[lc].siz+tr[rc].siz+1;
    tr[p].sum=tr[lc].sum+tr[p].val+tr[rc].sum;
    tr[p].pres=max(tr[lc].pres,tr[lc].sum+tr[p].val+max(0,tr[rc].pres));
    tr[p].sufs=max(tr[rc].sufs,tr[rc].sum+tr[p].val+max(0,tr[lc].sufs));
    tr[p].maxs=max(max(tr[lc].maxs,tr[rc].maxs),max(tr[p].val,tr[lc].sufs+tr[p].val+tr[rc].pres));
}

void cover_node(int p,int c){
    if(!p) return;
    tr[p].val=c;
    tr[p].sum=tr[p].siz*c;
    if(c>0){
        tr[p].pres=tr[p].sufs=tr[p].sum;
        tr[p].maxs=tr[p].sum;
    }else{
        tr[p].pres=tr[p].sufs=0;
        tr[p].maxs=c;
    }
    tr[p].cov=c;
}

void rev_node(int p){
    if (!p) return;
    swap(lc,rc);
    swap(tr[p].pres,tr[p].sufs);
    tr[p].rev^= 1;
}

void down(int p){
    if(tr[p].cov!=INF){
        if(lc) cover_node(lc,tr[p].cov);
        if(rc) cover_node(rc,tr[p].cov);
        tr[p].cov=INF;
        tr[p].rev=false;
    }
    if(tr[p].rev){
        if(lc) rev_node(lc);
        if(rc) rev_node(rc);
        tr[p].rev=false;
    }
}

void split(int p,int k,int &x,int &y){
    if(!p){
        x=y=0;
        return;
    }
    down(p);
    if(tr[lc].siz<k){
        x=p;
        split(rc,k-tr[lc].siz-1,rc,y);
    }else{
        y=p;
        split(lc,k,x,lc);
    }
    up(p);
}

int merge(int x, int y){
    if(!x||!y) return x+y;
    down(x);
    down(y);
    if(tr[x].pri<tr[y].pri){
        tr[x].son[1]=merge(tr[x].son[1],y);
        up(x);
        return x;
    }else{
        tr[y].son[0]=merge(x,tr[y].son[0]);
        up(y);
        return y;
    }
}

void recycle(int p){
    if(!p) return;
    recycle(lc);
    recycle(rc);
    mem_pool.push(p);
}

void insert(int pos, int tot, int a[]){
    int x,y;
    split(rt,pos,x,y);
    int p=0;
    build(p,1,tot,a);
    rt=merge(merge(x,p),y);
}

void remove(int pos,int tot){
    int x,y,z;
    split(rt,pos,x,y);
    split(y,tot,y,z);
    recycle(y);
    rt=merge(x,z);
}

void make_same(int pos,int tot,int c){
    int x,y,z;
    split(rt,pos,x,y);
    split(y,tot,y,z);
    cover_node(y,c);
    rt=merge(merge(x,y),z);
}

void reverse(int pos,int tot){
    int x,y,z;
    split(rt,pos,x,y);
    split(y,tot,y,z);
    rev_node(y);
    rt=merge(merge(x,y),z);
}

int get_sum(int pos,int tot){
    int x,y,z,sum;
    split(rt,pos,x,y);
    split(y,tot,y,z);
    sum=tr[y].sum;
    rt=merge(merge(x,y),z);
    return sum;
}

int get_max_sum(){
    return tr[rt].maxs;
}

int main(){
    srand(time(0));
    cin>>n>>m;
    int a[MAXN];
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    build(rt,1,n,a);
    char op[20];
    int pos,tot,c;
    while (m--){
        cin>>op;
        if(op[0]=='I'){
            cin>>ops>>tot;
            for(int i=1;i<=tot;i++){
                cin>>a[i];
            }
            insert(pos,tot,a);
        }else if(op[0]=='D'){
            cin>>pos>>tot;
            remove(pos,tot);
        }else if(op[0]=='M'&&op[2]=='K'){
            cin>>pos>>tot>>c;
            make_same(pos,tot,c);
        }else if(op[0]=='R'){
            cin>>pos>>tot;
            reverse(pos,tot);
        }else if(op[0]=='G'){
            cin>>pos>>tot;
            cout<<get_sum(pos,tot)<<endl;
        }else {
            cout<<get_max_sum()<<endl;
        }
    }
    return 0;
}