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 <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <ctype.h>
#include <iostream>
using namespace std;

const int N = 200010;
typedef long long ll;
const ll MAX =  9223372036854775807;

ll f[N<<2];
ll lazy[N<<2];				
char str[1200];

void build(int root, int left, int right)
{
	lazy[root] = 0;
	if(left == right)
	{
		scanf("%I64d",&f[root]);
		return;
	}
	
	int mid, rt;
	
	rt = root <<1;
	mid = (left + right)>>1;
	
	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 rt, mid;
	
	rt = root << 1;
	mid = (left + right) >> 1; 
	
	ll s = lazy[root];
	 
	
	lazy[rt] += s;
	lazy[rt + 1] += s;
	
	f[rt] += s * (mid - left + 1);
	f[rt + 1] += s * (right - mid);
	lazy[root] = 0;
}

void update(int root, int left, int right, int uleft, int uright, int val)
{
	if(uleft <= left && right <= uright)
	{
		f[root] += val;
		lazy[root] += val;
		return;
	}
	
	if(lazy[root] != 0)
	{
		pushdown(root, left, right);
	}
	
	int rt, mid;
	
	rt = root << 1;
	mid = (left + right) >> 1;
	
	if(uleft <= mid)
	{
		update(rt, left, mid, uleft, uright, val);
	}
	if(mid < uright)
	{
		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);
	}
	
	
	
	ll mid, rt, ans;
	
	rt = root << 1;
	mid = (left + right) >> 1;
	
	ans = MAX;
	
	if(qleft <= mid)
	{
		ans = query(rt, left, mid, qleft, qright);
	}
	if(mid < qright)
	{
		ans = min(query(rt, left, mid, qleft, qright), ans);
	}
	
	return ans;
	
}

int main()
{
	int n;
	scanf("%d",&n);
	
	build(1,0,n-1); 
	int m;
	scanf("%d",&m);
	getchar();
	int l, r, v;
	
	while(m--)
	{
		gets(str);
		if(sscanf(str, "%d %d %d", &l, &r, &v) == 3)
		{
			if(l <= r)
			{
				update(1,0,n-1,l,r,v);
			}
			else
			{
				update(1,0,n-1,l,n-1,v);
				update(1,0,n-1,0,r,v);
			}
		}
		else
		{
			ll ans;
			if(l <= r)
			{
				ans = query(1,0,n-1,l,r);
			}
			else
			{
				ans = query(1,0,n-1,l,n-1);
				ans = min(ans,query(1,0,n-1,0,r));
			}
			printf("%I64d\n", ans);
		}	
	} 

	return 0;


}

	 	 	  	 					   	 		 	  	  			