Iahub likes trees very much. Recently he discovered an interesting tree named propagating tree. The tree consists of *n* nodes numbered from 1 to *n*, each node *i* having an initial value *a*<sub class="lower-index">*i*</sub>. The root of the tree is node 1.

This tree has a special property: when a value *val* is added to a value of node *i*, the value -*val* is added to values of all the children of node *i*. Note that when you add value -*val* to a child of node *i*, you also add -(-*val*) to all children of the child of node *i* and so on. Look an example explanation to understand better how it works.

This tree supports two types of queries:
 -  "1 *x* *val*" — *val* is added to the value of node *x*; -  "2 *x*" — print the current value of node *x*. 
In order to help Iahub understand the tree better, you must answer *m* queries of the preceding type.
The first line contains two integers *n* and *m* (1 ≤ *n*, *m* ≤ 200000). 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> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 1000). Each of the next *n*–1 lines contains two integers *v*<sub class="lower-index">*i*</sub> and *u*<sub class="lower-index">*i*</sub> (1 ≤ *v*<sub class="lower-index">*i*</sub>, *u*<sub class="lower-index">*i*</sub> ≤ *n*), meaning that there is an edge between nodes *v*<sub class="lower-index">*i*</sub> and *u*<sub class="lower-index">*i*</sub>.

Each of the next *m* lines contains a query in the format described above. It is guaranteed that the following constraints hold for all queries: 1 ≤ *x* ≤ *n*, 1 ≤ *val* ≤ 1000.
# Fenwick tree class
class FenwickTree:
  def __init__(self, n):
    self.tree = [0] * (n+1)

  def add(self, i, val):
    while i < len(self.tree):
      self.tree[i] += val
      i += i & -i

  def sum(self, i):
    res = 0
    while i > 0:
      res += self.tree[i]
      i -= i & -i
    return res

# Propagating tree class
class PropagatingTree:
  def __init__(self, n, a):
    self.n = n
    self.a = a
    self.ft = FenwickTree(n)

  def add(self, i, val):
    self.a[i] += val
    self.ft.add(i, val)

  def query(self, i):
    return self.ft.sum(i) - self.ft.sum(i-1)

# Read input
n, m = map(int, input().split())
a = list(map(int, input().split()))

# Initialize propagating tree
pt = PropagatingTree(n, a)

# Process queries
for i in range(m):
  t, x = map(int, input().split())
  if t == 1:
    val = int(input())
    pt.add(x, val)
  else:
    print(pt.query(x))
