#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back

const int N=100050;

namespace MergeST {
	const int M=40000000;
	int ls[M],rs[M],tsz;
	ll sum[M],cnt[M];
	ll val[N];

	int cpy(int c){
		++tsz;
		sum[tsz]=sum[c];
		cnt[tsz]=cnt[c];
		ls[tsz]=ls[c];
		rs[tsz]=rs[c];
		return tsz;
	}
	void Add(int&c,int ss,int se,int qi,ll x,ll y){
		c=cpy(c);
		sum[c]+=x*y;
		cnt[c]+=x;
		if(ss==se)return;
		int mid=ss+se>>1;
		if(qi<=mid)Add(ls[c],ss,mid,qi,x,y);
		else Add(rs[c],mid+1,se,qi,x,y);
	}
	void Merge(int&c,int l,int r,int ss,int se){
		if(!l||!r)c=l^r;
		else{
			c=++tsz;
			sum[c]=sum[l]+sum[r];
			cnt[c]=cnt[l]+cnt[r];
			int mid=ss+se>>1;
			Merge(ls[c],ls[l],ls[r],ss,mid);
			Merge(rs[c],rs[l],rs[r],mid+1,se);
		}
	}
	void pull(int c){
		sum[c]=sum[ls[c]]+sum[rs[c]];
		cnt[c]=cnt[ls[c]]+cnt[rs[c]];
	}
	void Cut(int&c,int ss,int se,ll k){
		if(cnt[c]<=k)return;
		c=cpy(c);
		if(ss==se){
			if(cnt[c]>k){
				sum[c]-=val[ss]*(cnt[c]-k);
				cnt[c]=k;
			}
			return;
		}
		int mid=ss+se>>1;
		if(cnt[ls[c]]>=k){
			rs[c]=0;
			Cut(ls[c],ss,mid,k);
			pull(c);
		}else{
			Cut(rs[c],mid+1,se,k-cnt[ls[c]]);
			pull(c);
		}
	}
	ll Get(int c,int ss,int se,ll k){
		if(ss==se){
			return val[ss]*min(k,cnt[c]);
		}
		int mid=ss+se>>1;
		if(cnt[ls[c]]<=k){
			return Get(rs[c],mid+1,se,k-cnt[ls[c]])+sum[ls[c]];
		}
		return Get(ls[c],ss,mid,k);
	}
}


int t[N];
ll l[N],r[N],x[N],y[N];
int when[N],tid,n,m;

namespace ST{
	const int M=2*N;
	int ls[M],rs[M],tsz,root;
	int rt[M],sub[M];

	void Build(int &c,int ss,int se){
		c=++tsz;
		if(ss==se)return;
		int mid=ss+se>>1;
		Build(ls[c],ss,mid);
		Build(rs[c],mid+1,se);
	}

	void cut(int c,ll k){
		if(MergeST::cnt[rt[c]]>k){
			MergeST::Cut(rt[c],1,tid,MergeST::cnt[rt[c]]-k);
		}else{
			sub[c]+=k-MergeST::cnt[rt[c]];
			rt[c]=0;
		}
	}

	void push(int c){
		if(sub[c]>0){
			cut(ls[c],sub[c]);
			cut(rs[c],sub[c]);
			sub[c]=0;
		}
		if(MergeST::cnt[rt[c]]>0){
			MergeST::Merge(rt[ls[c]],rt[ls[c]],rt[c],1,tid);
			MergeST::Merge(rt[rs[c]],rt[rs[c]],rt[c],1,tid);
			rt[c]=0;
		}
	}

	void Add(int c,int ss,int se,int qs,int qe,int idx,ll x,ll y){
		if(qs>qe||qs>se||ss>qe)return;
		if(qs<=ss&&qe>=se){
			MergeST::Add(rt[c],1,tid,idx,x,y);
			return;
		}
		int mid=ss+se>>1;
		push(c);
		Add(ls[c],ss,mid,qs,qe,idx,x,y);
		Add(rs[c],mid+1,se,qs,qe,idx,x,y);
	}

	void Del(int c,int ss,int se,int qs,int qe,ll k){
		if(qs>qe||qs>se||ss>qe)return;
		if(qs<=ss&&qe>=se){
			cut(c,k);
			return;
		}
		int mid=ss+se>>1;
		push(c);
		Del(ls[c],ss,mid,qs,qe,k);
		Del(rs[c],mid+1,se,qs,qe,k);
	}

	int GetTree(int c,int ss,int se,int qi){
		if(ss==se)return rt[c];
		int mid=ss+se>>1;
		push(c);
		if(qi<=mid)return GetTree(ls[c],ss,mid,qi);
		return GetTree(rs[c],mid+1,se,qi);
	}
}


int main(){
	scanf("%i %i",&n,&m);
	vector<int> ids;
	for(int i=1;i<=m;i++){
		scanf("%i",&t[i]);
		if(t[i]==1){
			scanf("%lld %lld %lld %lld",&l[i],&r[i],&x[i],&y[i]);
		}else if(t[i]==2){
			scanf("%lld %lld %lld",&l[i],&r[i],&x[i]);
		}else{
			scanf("%lld %lld %lld",&x[i],&l[i],&r[i]);
			ids.pb(x[i]);
		}
	}
	sort(ids.begin(),ids.end());
	ids.erase(unique(ids.begin(),ids.end()),ids.end());
	for(int i=1;i<=m;i++){
		if(t[i]<=2){
			l[i]=lower_bound(ids.begin(),ids.end(),l[i])-ids.begin()+1;
			r[i]=upper_bound(ids.begin(),ids.end(),r[i])-ids.begin();
			if(l[i]<=r[i]){
				if(t[i]==1){
					when[i]=++tid;
					MergeST::val[tid]=y[i];
				}
			}
		}else{
			x[i]=lower_bound(ids.begin(),ids.end(),x[i])-ids.begin()+1;
		}
	}
	n=ids.size();

	ST::Build(ST::root,1,n);

	for(int i=1;i<=m;i++){
		if(t[i]==1){
			if(l[i]<=r[i]){
				ST::Add(ST::root,1,n,l[i],r[i],when[i],x[i],y[i]);
			}
		}else if(t[i]==2){
			if(l[i]<=r[i]){
				ST::Del(ST::root,1,n,l[i],r[i],x[i]);
			}
		}else{
			int rt=ST::GetTree(ST::root,1,n,x[i]);
			ll ans=MergeST::Get(rt,1,tid,r[i])-MergeST::Get(rt,1,tid,l[i]-1);
			//for(int i=1;i<=MergeST::cnt[rt];i++)printf("%lld ",MergeST::Get(rt,1,tid,i)-MergeST::Get(rt,1,tid,i-1));
			printf("%lld\n",ans);
		}

		/*printf("After query [%i]\n",i);
		for(int j=1;j<=n;j++){
			printf("---Stack %i---\n",ids[j-1]);
			int rt=ST::GetTree(ST::root,1,n,j);
			for(int i=1;i<=MergeST::cnt[rt];i++)printf("%lld ",MergeST::Get(rt,1,tid,i)-MergeST::Get(rt,1,tid,i-1));
			printf("\n");
		}
		printf("\n");*/
	}
	return 0;
}