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.
from sys import setrecursionlimit

setrecursionlimit(10 ** 9)

__author__ = 'Pavel Mavrin'

n, m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]

nb = [[] for x in range(n)]
for i in range(n - 1):
    x, y = [int(x) - 1 for x in input().split()]
    nb[x].append(y)
    nb[y].append(x)

p = [0] * (2 * n)
l = [0] * n
r = [0] * n
c = 0


def dfs(i, parent):
    global c
    global p
    l[i] = c
    p[c] = i
    c += 1
    for j in nb[i]:
        if j != parent:
            dfs(j, i)
            p[c] = i
            c += 1
    r[i] = c


dfs(0, -1)
nonode = [None, None, 0, 0]


def make_tree(l, r):
    if r == l + 1:
        if l % 2 == 0:
            return [nonode, nonode, a[p[l]]]
        else:
            return [nonode, nonode, -a[p[l]]]
    else:
        m = (l + r) // 2
        ll = make_tree(l, m)
        rr = make_tree(m, r)
        return [ll, rr, 0]


tree = make_tree(0, 2 * n)


def add(tree, l, r, a, b, val):
    if l >= b or a >= r:
        return
    if l >= a and r <= b:
        tree[2] += val
    else:
        m = (l + r) // 2
        tree[0][2] += tree[2]
        tree[1][2] += tree[2]
        add(tree[0], l, m, a, b, val)
        add(tree[1], m, r, a, b, val)
        tree[2] = 0


def get(tree, l, r, i):
    if r == l + 1:
        return tree[2]
    m = (l + r) // 2
    if i < m:
        return tree[2] + get(tree[0], l, m, i)
    else:
        return tree[2] + get(tree[1], m, r, i)


#print([get(tree, 0, 2 * n, i) for i in range(2 * n)])

for i in range(m):
    z = [int(x) for x in input().split()]
    if z[0] == 1:
        if l[z[1] - 1] % 2 == 0:
            add(tree, 0, 2 * n, l[z[1] - 1], r[z[1] - 1], z[2])
        else:
            add(tree, 0, 2 * n, l[z[1] - 1], r[z[1] - 1], -z[2])
#        print([get(tree, 0, 2 * n, i) for i in range(2 * n)])
    else:
        zz = get(tree, 0, 2 * n, l[z[1] - 1])
        if l[z[1] - 1] % 2 == 0:
            print(zz)
        else:
            print(-zz)



