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.
inp = input
out = print

n = int(inp())
a = [int(i) for i in inp().split()]

lo = []
hi = []
minv = []
val = []

for i in range(4*n+2):
    lo.append(0)
    hi.append(0)
    minv.append(0)
    val.append(0)

def push(node):
    val[2*node] += val[node]
    val[2*node+1] += val[node]
    val[node] = 0

def update(node):
    minv[node] = min(minv[2*node]+val[2*node],minv[2*node+1]+val[2*node+1])

def build(node, l, r):
    lo[node] = l
    hi[node] = r
    if l==r: 
        minv[node] = a[l]
        return
    mid = (l+r)//2
    build(node*2,l,mid)
    build(node*2+1,mid+1,r)
    update(node)

def inc(node, l, r, v):
    if r<lo[node] or hi[node]<l: 
        return
    if l<=lo[node] and hi[node]<=r:
        val[node] += v
        return
    push(node)
    inc(2*node, l, r, v)
    inc(2*node+1, l, r, v)
    update(node)

def rmq(node, l, r):
    if r<lo[node] or hi[node]<l: 
        return 1000000000
    if l<=lo[node] and hi[node]<=r:
        return minv[node]+val[node]
    push(node)
    minl = rmq(node*2, l, r)
    minr = rmq(node*2+1, l, r)
    update(node)
    return min(minl, minr)

build(1, 0, n-1)

m = int(inp())
while m>0:
    m -= 1
    st = inp().split()
    if len(st) == 3:
        l,r,v = map(int,st)
        if r<l: 
            inc(1,l,n-1,v)
            inc(1,0,r,v)
        else: inc(1, l, r, v)
    else:
        l,r = map(int,st)
        if r<l: out(min(rmq(1,l,n-1), rmq(1,0,r)))
        else: out(rmq(1, l, r))