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
import threading

setrecursionlimit(10 ** 9)
threading.stack_size(67108864)

__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


tree = [0] * (10 * n)

def make_tree(x, l, r):
    if r == l + 1:
        if l % 2 == 0:
            tree[x] = a[p[l]]
        else:
            tree[x] = -a[p[l]]
    else:
        m = (l + r) // 2
        make_tree(x * 2 + 1, l, m)
        make_tree(x * 2 + 2, m, r)


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


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


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

nonode = [None, None, 0, 0]

def main():
    dfs(0, -1)
    make_tree(0, 0, 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(0, 0, 2 * n, l[z[1] - 1], r[z[1] - 1], z[2])
            else:
                add(0, 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(0, 0, 2 * n, l[z[1] - 1])
            if l[z[1] - 1] % 2 == 0:
                print(zz)
            else:
                print(-zz)


thread = threading.Thread(target=main)
thread.start()







