There is a system of *n* vessels arranged one above the other as shown in the figure below. Assume that the vessels are numbered from 1 to *n*, in the order from the highest to the lowest, the volume of the *i*-th vessel is *a*<sub class="lower-index">*i*</sub> liters.

Initially, all the vessels are empty. In some vessels water is poured. All the water that overflows from the *i*-th vessel goes to the (*i* + 1)-th one. The liquid that overflows from the *n*-th vessel spills on the floor.

Your task is to simulate pouring water into the vessels. To do this, you will need to handle two types of queries:
 1.  Add *x*<sub class="lower-index">*i*</sub> liters of water to the *p*<sub class="lower-index">*i*</sub>-th vessel; 1.  Print the number of liters of water in the *k*<sub class="lower-index">*i*</sub>-th vessel. 
When you reply to the second request you can assume that all the water poured up to this point, has already overflown between the vessels.
The first line contains integer *n* — the number of vessels (1 ≤ *n* ≤ 2·10<sup class="upper-index">5</sup>). The second line contains *n* integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> — the vessels' capacities (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>). The vessels' capacities do not necessarily increase from the top vessels to the bottom ones (see the second sample). The third line contains integer *m* — the number of queries (1 ≤ *m* ≤ 2·10<sup class="upper-index">5</sup>). Each of the next *m* lines contains the description of one query. The query of the first type is represented as "1 *p*<sub class="lower-index">*i*</sub> *x*<sub class="lower-index">*i*</sub>", the query of the second type is represented as "2 *k*<sub class="lower-index">*i*</sub>" (1 ≤ *p*<sub class="lower-index">*i*</sub> ≤ *n*, 1 ≤ *x*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>, 1 ≤ *k*<sub class="lower-index">*i*</sub> ≤ *n*).
import sys
# import random
# from collections import Counter, defaultdict, deque
# from functools import lru_cache, reduce
# from itertools import accumulate,product
# from heapq import nsmallest, nlargest, heapify, heappop, heappush
# input = sys.stdin.buffer.readline
input = sys.stdin.readline
def mp():return list(map(int,input().split()))
def it():return int(input())
import math

mod=10**9+7

def solve():
    n=it()
    nums=mp()
    nums.append(math.inf)
    q=it()
    father=[i for i in range(n+1)]
    ans=[0]*(n+1)
    def find(x):
        while x!=father[x]:
            father[x]=father[father[x]]
            x=father[x]
        return x

    for i in range(q):
        get=mp()
        if len(get)==2:
            print(ans[get[1]-1])
        else:
            start,x=get[1]-1,get[2]
            ans[start]+=x
            while start<n and ans[start]>nums[start]:
                father[find(start)]=find(start+1)
                to=find(start+1)
                ans[to]+=ans[start]-nums[start]
                ans[start]=nums[start]
                start=to  

    return

if __name__ == '__main__':

    # t=it()
    # for _ in range(t):
        # solve()

    # n=it()
    # n,m,k=mp()
    # n,m=mp()
    solve()