F

#include <stdio.h>
#include <ctime>
#include <stdlib.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
typedef struct node* pnode;
typedef long long ll;
struct key
{
    ll val,s;
    int v;
    ll a,d;
    key(){}
    key(int _val)
    {
        val=_val;
        s=_val;
        v=-1;
        a=0;
        d=0;
    }
};

struct node
{
    key k;
    int p;
    int cnt;
    pnode l,r;
    node()
    {}
    node(int _val): k(_val)
    {
        p=rand();
        cnt=1;
        l=NULL;
        r=NULL;
    }
};

int count(pnode cur)
{
    return cur? cur->cnt:0;
}

ll getsum(pnode cur)
{
    return cur? cur->k.s:0;
}

void recalc(pnode cur)
{
    cur->cnt=count(cur->l)+count(cur->r)+1;
    cur->k.s=getsum(cur->l)+getsum(cur->r)+cur->k.val;
}



void push(pnode cur)
{
    if(cur!=NULL)
    {
        key *k=&cur->k;
        ll tmp_a0,tmp_d;
        if(k->v!=-1)
        {
            k->val=k->v;
            if(cur->l)
            {
                cur->l->k.v=k->v;
                cur->l->k.a=0;
                cur->l->k.d=0;
                cur->l->k.s=cur->l->cnt*k->v;
            }
            if(cur->r)
            {
                cur->r->k.v=k->v;
                cur->r->k.a=0;
                cur->r->k.d=0;
                cur->r->k.s=cur->r->cnt*k->v;
            }
        }
        k->v=-1;
        if(k->a||k->d)
        {
            int curindex=count(cur->l)+1;
            k->val+=k->a+k->d*(curindex-1);
            if(cur->l)
            {
                tmp_a0=k->a;
                tmp_d=k->d;
                cur->l->k.a+=tmp_a0;
                cur->l->k.d+=tmp_d;
                cur->l->k.s+=(tmp_a0+tmp_a0+tmp_d*(cur->l->cnt-1))*(cur->l->cnt)/2;
            }
            if(cur->r)
            {
                tmp_a0=k->a+k->d*(curindex);
                tmp_d=k->d;
                cur->r->k.a+=tmp_a0;
                cur->r->k.d+=tmp_d;
                cur->r->k.s+=(tmp_a0+tmp_a0+tmp_d*(cur->r->cnt-1))*(cur->r->cnt)/2;
            }
        }
        k->a=0;
        k->d=0;
    }
}

void split(pnode c,pnode &l,pnode &r,int k)
{
    push(c);
    if(c==NULL)
    {
        l=NULL;
        r=NULL;
        return;
    }

    int curidx=count(c->l)+1;
    if(curidx<=k)
    {
        split(c->r,c->r,r,k-curidx);
        l=c;
        recalc(l);
    }
    else
    {
        split(c->l,l,c->l,k);
        r=c;
        recalc(r);
    }
}

void merge(pnode &res,pnode l,pnode r)
{
    push(l);
    push(r);
    if(l==NULL)
    {
        res=r;
    }
    else if(r==NULL)
    {
        res=l;
    }
    else if(l->p>r->p)
    {
        merge(l->r,l->r,r);
        res=l;

    }
    else
    {
        merge(r->l,l,r->l);
        res=r;
    }
    recalc(res);
}

int main()
{
    srand(time(0));
    int i,j,v;
    int N,Q;
    int t;
    pnode root=NULL,tmp,l,c,r;
    scanf("%d%d",&N,&Q);
    for(int i=0;i<N;i++)
    {
        scanf("%d",&t);
        tmp=new node(t);
        merge(root,root,tmp);
    }
    while(Q--)
    {
        scanf("%d",&i);
        switch(i)
        {
        case 1:
            scanf("%d%d%d",&i,&j,&v);
            split(root,l,r,j);
            split(l,l,c,i-1);
            c->k.v=v;
            c->k.s=c->cnt*v;
            c->k.a=0;
            c->k.d=0;
            merge(l,l,c);
            merge(root,l,r);
            break;
        case 2:
            scanf("%d%d%d",&i,&j,&v);
            split(root,l,r,j);
            split(l,l,c,i-1);
            c->k.s+=v*c->cnt*(c->cnt+1)/2;
            c->k.a+=v;
            c->k.d+=v;
            merge(l,l,c);
            merge(root,l,r);
            break;
        case 3:
            scanf("%d%d",&i,&j);
            split(root,l,r,i-1);
            c=new node (j);
            merge(l,l,c);
            merge(root,l,r);
            break;
        case 4:
            scanf("%d%d",&i,&j);
            split(root,l,r,j);
            split(l,l,c,i-1);
            printf("%lld\n",getsum(c));
            merge(l,l,c);
            merge(root,l,r);
            break;
        }
    }
    return 0;
}