You are given circular array *a*<sub class="lower-index">0</sub>, *a*<sub class="lower-index">1</sub>, ..., *a*<sub class="lower-index">*n* - 1</sub>. There are two types of operations with it: 
 -  *inc*(*lf*, *rg*, *v*) — this operation increases each element on the segment [*lf*, *rg*] (inclusively) by *v*; -  *rmq*(*lf*, *rg*) — this operation returns minimal value on the segment [*lf*, *rg*] (inclusively). 
Assume segments to be circular, so if *n* = 5 and *lf* = 3, *rg* = 1, it means the index sequence: 3, 4, 0, 1.

Write program to process given sequence of operations.
The first line contains integer *n* (1 ≤ *n* ≤ 200000). The next line contains initial state of the array: *a*<sub class="lower-index">0</sub>, *a*<sub class="lower-index">1</sub>, ..., *a*<sub class="lower-index">*n* - 1</sub> ( - 10<sup class="upper-index">6</sup> ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">6</sup>), *a*<sub class="lower-index">*i*</sub> are integer. The third line contains integer *m* (0 ≤ *m* ≤ 200000), *m* — the number of operartons. Next *m* lines contain one operation each. If line contains two integer *lf*, *rg* (0 ≤ *lf*, *rg* ≤ *n* - 1) it means *rmq* operation, it contains three integers *lf*, *rg*, *v* (0 ≤ *lf*, *rg* ≤ *n* - 1; - 10<sup class="upper-index">6</sup> ≤ *v* ≤ 10<sup class="upper-index">6</sup>) — *inc* operation.
#include<cstdio>
#include<iostream>
using namespace std;

typedef long long ll;
const int N= 200005;
ll a[N],f[4*N],lazy[4*N];


void build(int root, int left, int right){
	lazy[root]=0;
	
	if(left==right){
		f[root]=a[left];
		return;
	}
	
	int mid,rt;
	rt=root*2;
	mid=(left+right)/2;
	
	build(rt,left,mid);
	build(rt+1,mid+1,right);
	
	f[root]=min(f[rt],f[rt+1]);
}

inline void pushdown(int root, int left, int right){
	int mid,rt;
	mid=(left+right)/2;
	rt=root*2;
	
	ll x=lazy[root];
	
	lazy[rt]+=x;
	lazy[rt+1]+=x;
	
	f[rt]+=x;
	f[rt+1]+=x;
	
	lazy[root]=0;
}

void update(int root, int left, int right, int uleft, int uright, ll val){
	if(uleft<=left && right<=uright){
		f[root]+=val;
		lazy[root]+=val;
		return;
	}
	
	if(lazy[root]!=0){
		pushdown(root,left,right);
	}
	
	int mid,rt;
	mid=(left+right)/2;
	rt=root*2;
	
	if(uleft<=mid){
		update(rt,left,mid,uleft,uright,val);
	}
	
	if(uright>mid){
		update(rt+1,mid+1,right,uleft,uright,val);
	}
	
	f[root]=min(f[rt],f[rt+1]);
}

ll query(int root, int left, int right, int qleft, int qright){
	if(qleft<=left && right<=qright){
		return f[root];
	}
	
	if(lazy[root]!=0){
		pushdown(root,left,right);
	}
	
	int mid,rt;
	ll ans=1000000000;;
	mid=(left+right)/2;
	rt=root*2;
	
	if(qleft<=mid){
		ans=min(ans,query(rt,left,mid,qleft,qright));
	}
	
	if(qright>mid){
		ans=min(ans,query(rt+1,mid+1,right,qleft,qright));
	}
	
	return ans;
}

int main(){
	int n,m;
	int x,y;
	ll v;
	char ch;
	
	scanf("%d", &n);
	for(int i=1;i<=n;i++){
		scanf("%I64d", &a[i]);
	}
	
	build(1,1,n);
	scanf("%d", &m);
	for(int i=1;i<=m;i++){
		
		scanf("%d%d%c", &x, &y, &ch);
		x++;
		y++;
		
		if(ch==' '){
			scanf("%I64d", &v);
			
			if(x<=y){
				update(1,1,n,x,y,v);
			}
			else{
				update(1,1,n,x,n,v);
				update(1,1,n,1,y,v);
			}
		}
		else{
			if(x<=y){
				printf("%I64d\n", query(1,1,n,x,y));
			}
			else{
				ll a1=query(1,1,n,x,n),a2=query(1,1,n,1,y);
				printf("%I64d\n", min(a1,a2));
			}
		}
	}
	return 0;
}















 			 	 		 				 	 	  			 	  		