#include<bits/stdc++.h>
using namespace std;
#define ll long long
const double alpha=0.25,beta=(1-alpha*2)/(1-alpha);
#define N 100010
namespace WBLT{
	struct data{
		ll sz,sum;
	};
	data operator+(data a,data b){
		return (data){a.sz+b.sz,a.sum+b.sum};
	}
	struct node{
		int ch[2],ncnt;
		data d;
	}d[15000000];
	int dcnt=1;
	int newnode(int ncnt,data z){
		assert(ncnt<150000000);
		int x=dcnt++;d[x].d=z;d[x].ncnt=ncnt;
		return x;
	}
	#define lc(x) d[x].ch[0]
	#define rc(x) d[x].ch[1]
	int cp(int x){
		int y=newnode(d[x].ncnt,d[x].d);
		lc(y)=lc(x),rc(y)=rc(x);return y;
	}
	void pushup(int x){
		assert(d[x].ncnt!=1);
		d[x].d=d[lc(x)].d+d[rc(x)].d;
		d[x].ncnt=d[lc(x)].ncnt+d[rc(x)].ncnt;
	}
	void turn(int x,int k){//both x and y must be copied
		int y=d[x].ch[k];
		swap(lc(x),rc(x));swap(lc(y),rc(y));swap(d[x].ch[k],d[y].ch[k^1]);
		pushup(y);
	}
	int combine(int x,int y){
		int z=newnode(d[x].ncnt+d[y].ncnt,d[x].d+d[y].d);
		lc(z)=x,rc(z)=y;return z;
	}
	int merge(int x,int y){
		if(!x||!y)return x+y;
		if(min(d[x].ncnt,d[y].ncnt)>alpha*(d[x].ncnt+d[y].ncnt))return combine(x,y);
		if(d[x].ncnt>d[y].ncnt){
			if(d[lc(x)].ncnt>alpha*(d[x].ncnt+d[y].ncnt))return combine(lc(x),merge(rc(x),y));
			return combine(merge(lc(x),lc(rc(x))),merge(rc(rc(x)),y));
		}else{
			if(d[rc(y)].ncnt>alpha*(d[x].ncnt+d[y].ncnt))return combine(merge(x,lc(y)),rc(y));
			return combine(merge(x,lc(lc(y))),merge(rc(lc(y)),rc(y)));
		}
	}
	void wblt(int x){//x must be copied
		assert(d[x].ncnt!=1);
		int k=0;
		if(d[lc(x)].ncnt<d[x].ncnt*alpha)k=1;
		else if(d[rc(x)].ncnt<d[x].ncnt*alpha)k=0;
		else return;
		int y=d[x].ch[k];
		if(d[d[y].ch[k^1]].ncnt>d[y].ncnt*beta){
			y=d[x].ch[k]=cp(d[x].ch[k]);
			d[y].ch[k^1]=cp(d[y].ch[k^1]);
			turn(y,k^1);
		}
		turn(x,k);
	}
	int del(int x,ll sz){
		assert(sz<=d[x].d.sz&&sz>=0);
		if(!sz)return x;
		if(sz==d[x].d.sz)return 0;
		if(d[x].ncnt==1){
			int y=cp(x);int v=d[x].d.sum/d[x].d.sz;
			d[y].d.sz-=sz;d[y].d.sum-=1LL*v*sz;return y;
		}
		if(sz>=d[rc(x)].d.sz)return del(lc(x),sz-d[rc(x)].d.sz);
		else{
			x=cp(x);rc(x)=del(rc(x),sz);
			wblt(x);
			return x;
		}
	}
	ll qry(int x,ll l,ll r){
		if(!x||r<1||l>d[x].d.sz)return 0;
		if(d[x].ncnt==1)return d[x].d.sum/d[x].d.sz*(min(d[x].d.sz,r)-max(1LL,l)+1);
		if(l<=1&&d[x].d.sz<=r)return d[x].d.sum;
		return qry(lc(x),l,r)+qry(rc(x),l,r);
	}
	#undef lc
	#undef rc
};
namespace SEG{
	struct tag{
		ll pp,rt;
		void spread(tag t){
			if(t.pp){
				if(t.pp>=WBLT::d[rt].d.sz)pp+=t.pp-WBLT::d[rt].d.sz,rt=0;
				else rt=WBLT::del(rt,t.pp);
			}
			rt=WBLT::merge(rt,t.rt);
		}
	};
	struct node{
		tag t;
	}d[N<<2];
	#define lc (rt<<1)
	#define rc ((rt<<1)|1)
	void pushdown(int rt){
		d[lc].t.spread(d[rt].t);
		d[rc].t.spread(d[rt].t);
		d[rt].t.pp=d[rt].t.rt=0;
	}
	ll qry(int rt,int l,int r,int x,int ql,int qr){
		if(l==r)return WBLT::qry(d[rt].t.rt,ql,qr);
		pushdown(rt);int mid=(l+r)>>1;
		if(x<=mid)return qry(lc,l,mid,x,ql,qr);
		else return qry(rc,mid+1,r,x,ql,qr);
	}
	void push(int rt,int l,int r,int ul,int ur,int x,int y){
		if(ul<=l&&r<=ur){
			d[rt].t.rt=WBLT::merge(d[rt].t.rt,WBLT::newnode(1,(WBLT::data){x,1LL*x*y}));//could do better
			return;
		}
		int mid=(l+r)>>1;pushdown(rt);
		if(ul<=mid)push(lc,l,mid,ul,ur,x,y);
		if(mid<ur)push(rc,mid+1,r,ul,ur,x,y);
	}
	void pop(int rt,int l,int r,int ul,int ur,ll x){
		if(ul<=l&&r<=ur){
			if(WBLT::d[d[rt].t.rt].d.sz<=x){d[rt].t.pp+=x-WBLT::d[d[rt].t.rt].d.sz;d[rt].t.rt=0;}
			else d[rt].t.rt=WBLT::del(d[rt].t.rt,x);
			return;
		}
		int mid=(l+r)>>1;pushdown(rt);
		if(ul<=mid)pop(lc,l,mid,ul,ur,x);
		if(mid<ur)pop(rc,mid+1,r,ul,ur,x);
	}
};
int n,m;
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int op;scanf("%d",&op);
		if(op==1){
			int l,r,x,y;scanf("%d%d%d%d",&l,&r,&x,&y);
			SEG::push(1,1,n,l,r,x,y);
		}else if(op==2){
			int l,r;ll w;scanf("%d%d%lld",&l,&r,&w);
			SEG::pop(1,1,n,l,r,w);
		}else{
			int k;ll l,r;scanf("%d%lld%lld",&k,&l,&r);
			printf("%lld\n",SEG::qry(1,1,n,k,l,r));
		}
	}
	return 0;
}