#include<iostream>
#include<cstdio>
#define N 100000
#define as 0.75
using namespace std;
const long long inf=(long long)(1e10);
long long read()
{
	char c=0;
	long long sum=0;
	while (c<'0'||c>'9') c=getchar();
	while ('0'<=c&&c<='9') sum=sum*10+c-'0',c=getchar();
	return sum;
}
bool used[300*N+1];
struct WBLT
{
	struct node
	{
		int ls,rs;
		long long sz,data;
	};
	node tree[300*N+1];
	int dque[300*N+1],top,length;
	int new_node(int d)
	{
		int nw;
		if (top) nw=dque[top--];
		else nw=++length;
	    tree[nw]=(node){0,0,1,d};
		return nw;
	}
	void push_up(int k)
	{
		tree[k].sz=tree[tree[k].ls].sz+tree[tree[k].rs].sz,tree[k].data=tree[tree[k].ls].data+tree[tree[k].rs].data;
		return;
	}
	int merge(int x,int y)
	{
		if (!x||!y) return x^y;
		int res=tree[x].sz+tree[y].sz;
		if (tree[x].sz>tree[y].sz)
		{
			if (tree[x].sz<=as*res)
			{
				int nw=new_node(0);
				tree[nw].ls=x,tree[nw].rs=y,push_up(nw);
				return nw;
			}
			else if (tree[tree[x].ls].sz>(1-as)*res) return merge(tree[x].ls,merge(tree[x].rs,y));
			else return merge(merge(tree[x].ls,tree[tree[x].rs].ls),merge(tree[tree[x].rs].rs,y));
		}
		else
		{
			if (tree[y].sz<=as*res)
			{
				int nw=new_node(0);
				tree[nw].ls=x,tree[nw].rs=y,push_up(nw);
				return nw;
			}
			else if (tree[tree[y].rs].sz>(1-as)*res) return merge(merge(x,tree[y].ls),tree[y].rs);
			else return merge(merge(x,tree[tree[y].ls].ls),merge(tree[tree[y].ls].rs,tree[y].rs));
		}
	}
	void split(int k,long long d,int &x,int &y)
	{
		if (!tree[k].ls)
		{
			if (!d) x=0,y=k;
			else x=k,y=0;
			return;
		}
		if (d<=tree[tree[k].ls].sz) split(tree[k].ls,d,x,y),y=merge(y,tree[k].rs);
		else split(tree[k].rs,d-tree[tree[k].ls].sz,x,y),x=merge(tree[k].ls,x);
		return;
	}
	void adder(int k)
	{
		if (used[k]) return;
		used[k]=1;
		if (tree[k].ls) adder(tree[k].ls);
		if (tree[k].rs) adder(tree[k].rs);
		return;	
	}
};
WBLT T;
struct reads
{
	long long sz;
	int data;
};
reads operator + (reads a,reads b)
{
	int A,B;
	if (T.tree[a.data].sz<=b.sz) return (reads){a.sz+b.sz-T.tree[a.data].sz,b.data};
	else
	{
		T.split(a.data,T.tree[a.data].sz-b.sz,A,B),A=T.merge(A,b.data);
		if (T.tree[A].sz>inf) T.split(A,inf,A,B);
		return (reads){a.sz,A};
	}
}
struct seg
{
	struct node
	{
		int l,r;
		reads lazy;
	};
	node tree[(N<<2)+1];
	void build(int k,int l,int r)
	{
		tree[k].l=l,tree[k].r=r;
		if (l==r) return;
		int mid=(l+r)>>1;
		build(k<<1,l,mid),build(k<<1|1,mid+1,r);
		return;
	}
	void spread(int k)
	{
		if (tree[k].lazy.sz||tree[k].lazy.data) tree[k<<1].lazy=tree[k<<1].lazy+tree[k].lazy,tree[k<<1|1].lazy=tree[k<<1|1].lazy+tree[k].lazy,tree[k].lazy=(reads){0,0};
		return;	
	}
	void add(int k,int l,int r,reads d)
	{
		if (tree[k].l==l&&tree[k].r==r)
		{
			tree[k].lazy=tree[k].lazy+d;
			return;
		}
		spread(k);
		int mid=(tree[k].l+tree[k].r)>>1;
		if (r<=mid) add(k<<1,l,r,d);
		else if (l>=mid+1) add(k<<1|1,l,r,d);
		else add(k<<1,l,mid,d),add(k<<1|1,mid+1,r,d);
		return;
	}
	long long query(int k,int x,long long p,long long q)
	{
		if (tree[k].l==tree[k].r)
		{
			int A,B,C,tmp;
			q=min(q,T.tree[tree[k].lazy.data].sz);
			if (p>q) return 0;
			T.split(tree[k].lazy.data,q,tmp,C),T.split(tmp,p-1,A,B);
			return T.tree[B].data;
		}
		spread(k);
		int mid=(tree[k].l+tree[k].r)>>1;
		if (x<=mid) return query(k<<1,x,p,q);
		else return query(k<<1|1,x,p,q);
	}
	void solve(int k)
	{
		if (tree[k].lazy.data) T.adder(tree[k].lazy.data);
		if (tree[k].l==tree[k].r) return;
		solve(k<<1),solve(k<<1|1);
		return;	
	}
};
seg T2;
int n,m;
int fast_pow(int a,int b)
{
	int res=0,mul=a;
	while (b)
	{
		if (b&1) res=T.merge(res,mul);
		mul=T.merge(mul,mul),b>>=1;
	}
	return res;
}
int main()
{
	int op,l,r,k,x,y;
	long long w,p,q;
	n=read(),m=read(),T2.build(1,1,n);
	for (int i=1;i<=m;++i)
	{
		op=read();
		if (op==1) l=read(),r=read(),x=read(),y=read(),T2.add(1,l,r,(reads){0,fast_pow(T.new_node(y),x)});
		else if (op==2) l=read(),r=read(),w=read(),T2.add(1,l,r,(reads){w,0});
		else k=read(),p=read(),q=read(),printf("%lld\n",T2.query(1,k,p,q));
		if (T.length-T.top>290*N)
		{
			for (int j=1;j<=T.length;++j) used[j]=0;
			T2.solve(1);
			for (int j=1;j<=T.length;++j)
				if (!used[j])
					T.dque[++T.top]=j;
		}
	}
	return 0;
}