#include<bits/stdc++.h>
#define ll long long
#define ls(u)t[u].ls
#define rs(u) t[u].rs
using namespace std;
const int N=3e5+5,M=4e6+5,MAXN=3.6e6+5;
const ll mod=1e9+7;
int n,m,root,cnt,pos;
int a[N];
struct FHQ_Treap
{
	int ls,rs;
	int val,sum,tag,cov;
	bool rev;
	int siz;
}t[M];
int newNode(ll x)
{
	int u=++cnt;
	t[u].ls=t[u].rs=t[u].tag=t[u].rev=0;
	t[u].cov=-1;
	t[u].val=t[u].sum=x;
	t[u].siz=1;
	return u;
}
int clone(int u)
{
	t[++cnt]=t[u];
	return cnt;
}
void update(int u)
{
	t[u].siz=t[ls(u)].siz+t[rs(u)].siz+1;
	t[u].sum=((t[ls(u)].sum+t[rs(u)].sum)%mod+t[u].val)%mod;
}
void cover(int u,ll k)
{
	if(!u) return;
	t[u].tag=0;
	t[u].val=t[u].cov=k;
	t[u].sum=(ll)(t[u].siz*k)%mod;
}
void add(int u,ll k)
{
	if(!u) return;
	t[u].val=(t[u].val+k)%mod;
	t[u].tag=(t[u].tag+k)%mod;
	t[u].sum=(t[u].sum+(ll)t[u].siz*k)%mod;
}
void reverse(int u)
{
	if(!u) return;
	swap(ls(u),rs(u));
	t[u].rev^=1;
}
void push_down(int u)
{
	if(!t[u].tag&&t[u].cov==-1&&!t[u].rev) return;
	if(ls(u)) ls(u)=clone(ls(u));
	if(rs(u)) rs(u)=clone(rs(u));
	if(t[u].cov!=-1)
	{
		if(ls(u)) cover(ls(u),t[u].cov);
		if(rs(u)) cover(rs(u),t[u].cov);
		t[u].cov=-1;
	}
	if(t[u].tag)
	{
		if(ls(u)) add(ls(u),t[u].tag);
		if(rs(u)) add(rs(u),t[u].tag);
		t[u].tag=0;
	}
	if(t[u].rev)
	{
		if(ls(u)) reverse(ls(u));
		if(rs(u)) reverse(rs(u));
		t[u].rev=0;
	}
}
void spilt(int u,int x,int &L,int &R)
{
	if(!u)
	{
		L=R=0;
		return;
	}
	push_down(u);
	if(t[ls(u)].siz+1<=x)
	{
		L=clone(u);
		spilt(t[L].rs,x-t[ls(u)].siz-1,t[L].rs,R);
		update(L);
	}
	else
	{
		R=clone(u);
		spilt(t[R].ls,x,L,t[R].ls);
		update(R);
	}
}
int merge(int L,int R)
{
	if(!L||!R) return L|R;
	if(rand()%(t[L].siz+t[R].siz)<t[L].siz)
	{
		push_down(L);
		L=clone(L);
		t[L].rs=merge(t[L].rs,R);
		update(L);
		return L;
	}
	else
	{
		push_down(R);
		R=clone(R);
		t[R].ls=merge(L,t[R].ls);
		update(R);
		return R;
	}
}
int build(int l,int r)
{
	if(l>r) return 0;
	int mid=(l+r)>>1,u=newNode(a[mid]);
	ls(u)=build(l,mid-1);
	rs(u)=build(mid+1,r);
	update(u);
	return u;
}
void dfs(int u)
{
	push_down(u);
	if(ls(u)) dfs(ls(u));
	a[++pos]=t[u].val;
	if(rs(u)) dfs(rs(u));
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
		scanf("%d",a+i);
	root=build(1,n);
	while(m--)
	{
		int opt,l1,l2,r1,r2,L,R,p;
		ll k;
		scanf("%d%d%d",&opt,&l1,&r1);
		if(opt==1)
		{
			spilt(root,r1,L,R);
			spilt(L,l1-1,L,p);
			printf("%d\n",t[p].sum);
			root=merge(merge(L,p),R);
		}
		if(opt==2)
		{
			scanf("%lld",&k);
			spilt(root,r1,L,R);
			spilt(L,l1-1,L,p);
			p=clone(p);
			cover(p,k);
			root=merge(merge(L,p),R);
		}
		if(opt==3)
		{
			scanf("%lld",&k);
			spilt(root,r1,L,R);
			spilt(L,l1-1,L,p);
			p=clone(p);
			add(p,k);
			root=merge(merge(L,p),R);
		}
		if(opt==4)
		{
			scanf("%d%d",&l2,&r2);
			bool flag=false;
			int a,b,c,d,e;
			if(l1>l2)
			{
				swap(l1,l2);
				swap(r1,r2);
				flag=true;
			}
			spilt(root,r2,d,e);
			spilt(d,l2-1,c,d);
			spilt(c,r1,b,c);
			spilt(b,l1-1,a,b);
			if(flag) root=merge(a,merge(d,merge(c,merge(d,e))));
				else root=merge(a,merge(b,merge(c,merge(b,e))));
			
		}
		if(opt==5)
		{
			scanf("%d%d",&l2,&r2);
			int a,b,c,d,e;
			if(l1>l2)
			{
				swap(l1,l2);
				swap(r1,r2);
			}
			spilt(root,r2,d,e);
			spilt(d,l2-1,c,d);
			spilt(c,r1,b,c);
			spilt(b,l1-1,a,b);
			root=merge(a,merge(d,merge(c,merge(b,e))));
		}
		if(opt==6)
		{
			spilt(root,r1,L,R);
			spilt(L,l1-1,L,p);
			p=clone(p);
			reverse(p);
			merge(merge(L,p),R);
		}
		if(cnt>MAXN)
		{
			pos=0;
			dfs(root);
			cnt=0;
			root=build(1,n);
		}
	}
	pos=0;
	dfs(root);
	for(int i=1;i<=n;i++) printf("%d ",a[i]);
	return 0;
}