You are given circular array a0, a1, ..., an - 1. 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.

Input

The first line contains integer n (1 ≤ n ≤ 200000). The next line contains initial state of the array: a0, a1, ..., an - 1 ( - 106 ≤ ai ≤ 106), ai 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; - 106 ≤ v ≤ 106) — inc operation.

Output

For each rmq operation write result for it. Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).

Examples

Input

4
1 2 3 4
4
3 0
3 0 -1
0 1
2 1


Output

1
0
0
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

public class TestClass {
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	
	public static class Queue{
		private class node{
			int val;
			node next;
			node(int a){
				val = a;
				next = null;
			}
		}
		node head,tail;
		Queue(){
			head = null;
			tail = null;
		}
		public void EnQueue(int a){
			if(head==null){
				node p = new node(a);
				head = p;
				tail = p;
			}
			else{
				node p = new node(a);
				tail.next = p;
				tail = p;
			}
		}
		public int DeQueue(){
			int a = head.val;
			head = head.next;
			return a;
		}
		public boolean isEmpty(){
			return head==null;
		}
	}
	public static long pow(long x,long y,long m){
		if(y==0)
    		return 1;
    	long k = pow(x,y/2,m);
    	if(y%2==0)
    		return (k*k)%m;
    	else
    		return (((k*k)%m)*x)%m;
    }
	static long Inversex = 0,Inversey = 0;
	public static void InverseModulo(long a,long m){
		if(m==0){
			Inversex = 1;
			Inversey = 0;
		}
		else{
    		InverseModulo(m,a%m);
    		long temp = Inversex;
    		Inversex = Inversey;
    		Inversey = temp+ - (a/m)*Inversey;
    	}
    }
    static long mod1 = 1000000007;
    static long mod2 = 1000000009;
	public static long gcd(long a,long b){
		if(a%b==0)
			return b;
		return gcd(b,a%b);
	}
	public static boolean isPrime(long a){
		if(a==1)
			return false;
		else if(a==2||a==3)
			return true;
		for(long i=2;i<=Math.sqrt(a);i++)
			if(a%i==0)
				return false;
		return true;
	}
	public static double distance(int a,int b,int x,int y){
		return Math.sqrt(((long)(a-x)*(long)(a-x))+((long)(b-y)*(long)(b-y)));
	}
	public static class Pair implements Comparable<Pair> {
		long u;
		long v;
		BigInteger bi;
		public Pair(long u, long v) {
			this.u = u;
			this.v = v;
		}
		public int hashCode() {
			int hu = (int) (u ^ (u >>> 32));
			int hv = (int) (v ^ (v >>> 32));
			return 31 * hu + hv;
		}
		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return u == other.u && v == other.v;
		}
		public int compareTo(Pair other) {
			return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
		}
		public String toString() {
			return u+" "+v;
		}
	}
	public static int sieve(int a[],boolean b[]){
		int count = 0;
		b[0] = true;
		b[1] = true;
		for(int i=2;i<a.length;i++){
			if(!b[i]){
				for(int j=2*i;j<a.length;j=j+i){
					b[j] = true;	
				}
				a[count++] = i;
			}
		}
		return count;
	}
	public static void MatrixMultiplication(int a[][],int b[][],int c[][]){
		for(int i=0;i<a.length;i++){
			for(int j=0;j<b[0].length;j++){
				c[i][j] = 0;
				for(int k=0;k<b.length;k++)
					c[i][j]=(int)((c[i][j]+((a[i][k]*(long)b[k][j])%mod1))%mod1);
			}
		}
	}
	public static void Equal(int arr[][],int temp[][]){
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr.length;j++)
				temp[i][j] = arr[i][j];
		}
	}
	public static class Trie {
		Node head;
		private class Node{
			Node a[] = new Node[2];
			boolean val;
			Node(){
				a[0] = null;
				a[1] = null;
				val = false;
			}
		}
		Trie(){
			head = new Node();
		}
		public void insert(Stack<Integer> s){
			Node temp = head;
			while(!s.isEmpty()){
				int q = s.pop();
				if(temp.a[q]==null)
					temp.a[q] = new Node();
				temp = temp.a[q];
			}
			temp.val = true;
		}
		public Node delete(Stack<Integer> s,Node temp){
			if(s.isEmpty())
				return null;
			int q = s.pop();
			temp.a[q] = delete(s,temp.a[q]);
			if(temp.a[q]==null&&temp.a[q^1]==null)
				return null;
			else
				return temp;
		}
		public void get(Stack<Integer> s,Stack<Integer> p){
			Node temp = head;
			while(!p.isEmpty()){
				int q = p.pop();
				if(temp.a[q]!=null){
					s.push(q);
					temp = temp.a[q];
				}
				else{
					s.push(q^1);
					temp = temp.a[q^1];
				}
			}
		}
	}
	/*public static void Merge(long a[][],int p,int r){
        if(p<r){
            int q = (p+r)/2;
            Merge(a,p,q);
            Merge(a,q+1,r);
            Merge_Array(a,p,q,r);
        }
    }
	public static void get(long a[][],long b[][],int i,int j){
		for(int k=0;k<a[i].length;k++)
			a[i][k] = b[j][k];
	}
    public static void Merge_Array(long a[][],int p,int q,int r){
        long b[][] = new long[q-p+1][a[0].length];
        long c[][] = new long[r-q][a[0].length];
        for(int i=0;i<b.length;i++){
            get(b,a,i,p+i);
        }
        for(int i=0;i<c.length;i++){
            get(c,a,i,q+i+1);
        }
        int i = 0,j = 0;
        for(int k=p;k<=r;k++){
            if(i==b.length){
                get(a,c,k,j);
                j++;
            }
            else if(j==c.length){
                get(a,b,k,i);
                i++;
            }
            else if(b[i][0]<c[j][0]){
                get(a,b,k,i);
                i++;
            }
            else{
                get(a,c,k,j);
                j++;
            }
        }
    }
    public static void powMatrix(long n){
    	if(n<=1)
    		return ;
    	powMatrix(n/2);
    	MatrixMultiplication(temp2,temp2,result);
		Equal(result,temp2);
    	if(n%2==1){
    		MatrixMultiplication(temp2,a,result);
    		Equal(result,temp2);
    	}
    }
    static int result[][] = new int[4][4];
	static int temp[][] = new int[4][4];
	static int temp2[][] = new int[4][4];
	static int a[][] = new int[4][4];
	static int[][] b = new int[4][1];
	static int [][] c = new int[4][1];
    public static int count(long n){
		a[0][0] = 1 ;
		a[0][1] = 1;
		a[1][0] = 1;
		a[2][1] = 1;
		a[3][0] = 1;
		a[3][1] = 1;
		a[3][3] = 1;
		b[0][0] = 1;
		b[1][0] = 1;
		b[2][0] = 0;
		b[3][0] = 2;
		Equal(a,temp2);
		result[0][0] = 1;
		result[1][1] = 1;
		result[2][2] = 1;
		result[3][3] = 1;
		Equal(result,temp);
		if(n<=0)
			return 0;
		else if(n==1)
			return 1;
		else if(n==2)
			return 2;
		n = n-2;
		powMatrix(n);
		MatrixMultiplication(temp2,b,c);
		return c[3][0];
	}*/
	public static class SegmentTree{
		long[] arr = new long[5000000];
		long[] lazy = new long[5000000];
		SegmentTree(long a[]){
			Build(a,0,a.length-1,0);
		}
		public void Build(long a[],int p,int q,int r){
			if(p==q){
				arr[r] = a[p];
				return ;
			}
			int mid = (p+q)/2;
			Build(a,p,mid,2*r+1);
			Build(a,mid+1,q,2*r+2);
			arr[r] = Math.min(arr[2*r+1],arr[2*r+2]);
		}
		public long getSum(int p,int q,int x,int y,int z){
			if(lazy[z]!=0){
				arr[z]+=lazy[z];
				lazy[2*z+1]+=lazy[z];
				lazy[2*z+2]+=lazy[z];
				lazy[z] = 0;
			}
			if(y<p||x>q)
				return Long.MAX_VALUE;
			if(p<=x&&q>=y)
				return arr[z];
			int mid = (x+y)/2;
			return Math.min(getSum(p,q,x,mid,2*z+1),getSum(p,q,mid+1,y,2*z+2));
		}
		public void Update(int p,int q,int x,int y,int z,int dif){
			if(lazy[z]!=0){
				arr[z]+=lazy[z];
				lazy[2*z+1] += lazy[z];
				lazy[2*z+2] += lazy[z];
				lazy[z] = 0;
			}
			if(p>y||q<x||p>q)
				return ;
			if(x<=p&&q<=y){
				arr[z]+=dif;
				lazy[2*z+1]+=dif;
				lazy[2*z+2]+=dif;
				return ;
			}
			int mid = (p+q)/2;
			Update(p,mid,x,y,2*z+1,dif);
			Update(mid+1,q,x,y,2*z+2,dif);
			arr[z] = Math.min(arr[2*z+1],arr[2*z+2]);
		}
	}
	private static void soln(){
		int n = nI();
		long arr[] = new long[n];
		for(int i=0;i<n;i++)
			arr[i] = nL();
		SegmentTree m = new SegmentTree(arr);
		int t = nI();
		while(t-->0){
			String h[] = nLi().split(" ");
			if(h.length==2){
				int x = Integer.parseInt(h[0]);
				int y = Integer.parseInt(h[1]);
				if(x>y)
					pw.println(Math.min(m.getSum(x, n-1, 0, n-1, 0), m.getSum(0, y, 0, n-1, 0)));
				else
					pw.println(m.getSum(x, y, 0, n-1, 0));
			}
			else{
				int x = Integer.parseInt(h[0]);
				int y = Integer.parseInt(h[1]);
				int z = Integer.parseInt(h[2]);
				if(x>y){
					m.Update(0, n-1, x, n-1, 0, z);
					m.Update(0, n-1, 0, y, 0, z);
				}
				else
					m.Update(0, n-1, x, y, 0, z);
			}
		}
	}
	public static void main(String[] args) {
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		soln();
		pw.close();
	}
	// To Get Input
	// Some Buffer Methods
	public static void InputReader(InputStream stream1) {
		stream = stream1;
	}
	private static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
	private static boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
	private static int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}
	private static int nI() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	private static long nL() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	private static String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}
	private static String nLi() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}
	private static int[] nIA(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = nI();
		return arr;
	}
	private static long[] nLA(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++)
			arr[i] = nL();
		return arr;
	}
	private static void pArray(int[] arr) {
		for (int i = 0; i < arr.length; i++)
			pw.print(arr[i] + " ");
		pw.println();
		return;
	}
	private static void pArray(long[] arr) {
		for (int i = 0; i < arr.length; i++)
			pw.print(arr[i] + " ");
		pw.println();
		return;
	}
	private static boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}
	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}