#include<bits/stdc++.h>
#define int long long 
#define max(a,b) Max(a,b)
#define min(a,b) Min(a,b)
using namespace std;
const int N=5e5+10;
const int INF=1e18;

int n,m,e[N];
inline int Max(const int &x,const int &y) {
	return x>y?x:y;
}
inline int Min(const int &x,const int &y) {
	return x<y?x:y;
}
namespace SGT {
	struct Segement_Tree {
		int l,r,val;
		int maxx,cmax,cnt1,hs1;
		int minn,cmin,cnt2,hs2;
		int tag1,tag2,add;
#define ls u<<1
#define rs u<<1|1
#define len(u) (t[u].r-t[u].l+1)
	}t[N<<2];
	inline void push_up(int u) {
		if (t[ls].maxx==t[rs].maxx) {
			t[u].maxx=t[ls].maxx;
			t[u].cnt1=t[ls].cnt1+t[rs].cnt1;
			t[u].cmax=max(t[ls].cmax,t[rs].cmax);
		}
		if (t[ls].maxx>t[rs].maxx) {
			t[u].maxx=t[ls].maxx;
			t[u].cnt1=t[ls].cnt1;
			t[u].cmax=max(t[ls].cmax,t[rs].maxx);
		}
		if (t[rs].maxx>t[ls].maxx) {
			t[u].maxx=t[rs].maxx;
			t[u].cnt1=t[rs].cnt1;
			t[u].cmax=max(t[ls].maxx,t[rs].cmax);
		}
		if (t[ls].minn==t[rs].minn) {
			t[u].minn=t[ls].minn;
			t[u].cnt2=t[ls].cnt2+t[rs].cnt2;
			t[u].cmin=min(t[ls].cmin,t[rs].cmin);
		}
		if (t[ls].minn<t[rs].minn) {
			t[u].minn=t[ls].minn;
			t[u].cnt2=t[ls].cnt2;
			t[u].cmin=min(t[ls].cmin,t[rs].cmin);
		}
		if (t[rs].minn<t[ls].minn) {
			t[u].minn=t[rs].minn;
			t[u].cnt2=t[rs].cnt2;
			t[u].cmin=min(t[ls].cmin,t[rs].cmin);
		}
		t[u].val=t[ls].val+t[rs].val;
		return ;
	}
	inline void push_tag1(int u,int tag) {
		if (t[u].maxx<=tag) return ;
		t[u].val+=(tag-t[u].maxx)*t[u].cnt1;
		if (t[u].cmin==t[u].maxx) t[u].cmin=tag;
		if (t[u].minn==t[u].maxx) t[u].minn=tag;
		if (t[u].tag1>tag) t[u].tag1=tag;
		t[u].maxx=t[u].tag1=tag;
		return ;
	}
	inline void push_tag2(int u,int tag) {
		if (t[u].minn>tag) return ;
		t[u].val+=(tag-t[u].minn)*t[u].cnt2;
		if (t[u].cmax==t[u].minn) t[u].cmax=tag;
		if (t[u].maxx==t[u].minn) t[u].maxx=tag;
		if (t[u].tag2<tag) t[u].tag2=tag;
		t[u].minn=t[u].tag2=tag;
		return ;
	}
	inline void push_add(int u,int val) {
		if (!val) return ;
		t[u].val+=len(u)*val,t[u].add+=val;
		t[u].maxx+=val,t[u].minn+=val;
		if (t[u].tag1!=-INF) t[u].tag1+=val;
		if (t[u].tag2!=INF) t[u].tag2+=val;
		if (t[u].cmax!=-INF) t[u].cmax+=val;
		if (t[u].cmin!=INF) t[u].cmin+=val;
		return ;
	} 
	inline void push_down(int u) {
		if (t[u].add) {
			push_add(ls,t[u].add);
			push_add(rs,t[u].add);
			t[u].add=0;
		}
		if (t[u].tag1!=-INF) {
			push_tag1(ls,t[u].tag1); 
			push_tag1(rs,t[u].tag1);
			t[u].hs1=0,t[u].tag1=-INF;
		}
		if (t[u].tag2!=INF) {
			push_tag2(ls,t[u].tag2);
			push_tag2(rs,t[u].tag2);
			t[u].hs2=0,t[u].tag2=INF;
		}
		return ;
	}
	inline void build(int u,int l,int r) {
		t[u].l=l,t[u].r=r,t[u].tag1=-INF,t[u].tag2=INF;
		if (l==r) return t[u].val=t[u].maxx=t[u].minn=e[l],t[u].cnt1=t[u].cnt2=1,t[u].cmin=INF,t[u].cmax=-INF,void();
		int mid=l+r>>1;
		build(ls,l,mid),build(rs,mid+1,r);
		return push_up(u);
	}
	inline void update_min(int u,int l,int r,int val) {         //[L,R] 变为 min(ai,val)
		if (t[u].maxx<=val) return ;
		if (t[u].l>=l and t[u].r<=r and val>t[u].cmax) {
			push_tag1(u,val);
			return ;
		}
		push_down(u);
		int mid=t[u].l+t[u].r>>1;
		if (l<=mid) update_min(ls,l,r,val);
		if (r>mid) update_min(rs,l,r,val);
		return push_up(u);
	}
	inline void update_max(int u,int l,int r,int val) {         //[L,R] 变为 max(ai,val)
		if (t[u].minn>=val) return ;
		if (t[u].l>=l and t[u].r<=r and val<t[u].cmin) {
			push_tag2(u,val);
			return ;
		}
		push_down(u);
		int mid=t[u].l+t[u].r>>1;
		if (l<=mid) update_max(ls,l,r,val);
		if (r>mid) update_max(rs,l,r,val);
		return push_up(u);
	}
	inline void modify(int u,int l,int r,int val) {
		if (t[u].l>=l and t[u].r<=r) {
			push_add(u,val);
			return ;
		}
		push_down(u);
		int mid=t[u].l+t[u].r>>1;
		if (l<=mid) modify(ls,l,r,val);
		if (r>mid) modify(rs,l,r,val);
		return push_up(u);
	}
	inline int query_sum(int u,int l,int r) {
		if (t[u].l>=l and t[u].r<=r) return t[u].val;
		push_down(u);
		int mid=t[u].l+t[u].r>>1,res=0;
		if (l<=mid) res+=query_sum(ls,l,r);
		if (r>mid) res+=query_sum(rs,l,r);
		return push_up(u),res;
	}
	inline int query_max(int u,int l,int r) {
		if (t[u].l>=l and t[u].r<=r) return t[u].maxx;
		push_down(u);
		int mid=t[u].l+t[u].r>>1,res=-INF;
		if (l<=mid) res=max(query_max(ls,l,r),res);
		if (r>mid) res=max(query_max(rs,l,r),res);
		return push_up(u),res;
	}
	inline int query_min(int u,int l,int r) {
		if (t[u].l>=l and t[u].r<=r) return t[u].minn;
		push_down(u);
		int mid=t[u].l+t[u].r>>1,res=INF;
		if (l<=mid) res=min(query_min(ls,l,r),res);
		if (r>mid) res=min(query_min(rs,l,r),res); 
		return push_up(u),res;
	}
}using namespace SGT;
inline void solve() {
	cin>>n;
	for (int i=1;i<=n;i++) cin>>e[i];
	build(1,1,n);
	cin>>m;
	while (m--) {
		int op,l,r,val;
		cin>>op>>l>>r;
		if (op==1) {
			cin>>val;
			modify(1,l,r,val);
		}
		if (op==2) {                  //[L,R] 变为 max(ai,val)
			cin>>val;
			update_max(1,l,r,val);
		}
		if (op==3) {
			cin>>val;                 //[L,R] 变为 min(ai,val)
			update_min(1,l,r,val);   
		}
		if (op==4) {
			cout<<query_sum(1,l,r)<<endl;
		}
		if (op==5) {
			cout<<query_max(1,l,r)<<endl;
		}
		if (op==6) {
			cout<<query_min(1,l,r)<<endl;
		}
	}
	return ;
}
signed main() {
	solve();
	return (0-0);
}
/*

*/