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>
#include<cmath>
#include<algorithm>
using namespace std;
const int N = 2e5 + 5;
int f[N * 4];
int lazy[N * 4], a[N];
int minn= 10000000;
void build(int root, int left, int right) {
	lazy[root] = 0;
	if (left == right) {
		f[root] = a[left];
		return;
	}
	int rt, mid;
	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]);
}
void pushdown(int root, int left, int right) {
	if (lazy[root]) {
		int rt = root * 2;
		int s = lazy[root];
		f[rt] += s;
		f[rt + 1] += s;
		lazy[rt] = s;
		lazy[rt + 1] = s;
		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;
	}
	int rt, mid;
	rt = root << 1;
	mid = (left + right) >> 1;
	pushdown(root, left, right);
	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]);
}
int query(int root, int left, int right, int qleft, int qright) {
	if (qleft <= left && right <= qright) {
		return f[root];
	}
	pushdown(root, left, right);
	int rt, mid;
	rt = root << 1;
	mid = (left + right) >> 1;
	if (qleft <= mid) {
		minn = min(minn, query(rt, left, mid, qleft, qright));
	}
	if (qright > mid) {
		minn = min(minn, query(rt + 1, mid + 1, right, qleft, qright));
	}
	return minn;
}
int main() {
	int n;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
	}
	build(1, 1, n);
	int q;
	scanf("%d", &q);
	while (q--) {
		minn = 10000000;
		int x, y, v;
		scanf("%d%d", &x, &y);
		x++;
		y++;
		char ch;
		ch = getchar();
		if (ch != '\n') {
			scanf("%d", &v);
			if (x > y) {
				update(1, 1, n, x, n, v);
				update(1, 1, n, 1, y, v);
			}
			else {
				update(1, 1, n, x, y, v);
			}
		}
		else {
			int ans;
			if (x > y) {
				ans = min(query(1, 1, n, x, n), query(1, 1, n, 1, y));
			}
			else {
				ans = query(1, 1, n, x, y);
			}
			printf("%d\n", ans);
		}
	}
	return 0;
}

 				 		 	  	   			 	   	 	   	