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

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def LS2(): return list(sys.stdin.readline().rstrip())


class BIT:
    def __init__(self,init_value):
        self.n = len(init_value)
        self.tree = [0]*(self.n+1)
        for i in range(1,self.n+1):
            x = init_value[i-1]
            while i <= self.n:
                self.tree[i] += x
                i += i & (-i)

    def update(self,i,x):  # i(1-based)番目の値を+x
        while i <= self.n:
            self.tree[i] += x
            i += i & (-i)
        return

    def query(self,i):  # 1番目からi(1-based)番目までの和を返す
        res = 0
        while i > 0:
            res += self.tree[i]
            i -= i & (-i)
        return res

    def get_val(self,i):  # i番目の値を取得
        return self.query(i)-self.query(i-1)


m,n = MI()
A = [0]+LI()
Graph = [[] for _ in range(n+1)]
for _ in range(n-1):
    u,v = MI()
    Graph[u].append(v)
    Graph[v].append(u)

tour = []  # オイラーツアー
is_visit = [0]*(n+1)
is_visit[1] = 1


def dfs(u):
    tour.append(u)
    for v in Graph[u]:
        if not is_visit[v]:
            is_visit[v] = 1
            dfs(v)
            tour.append(u)


dfs(1)

F = [-1]*(n+1)  # F[t] = 頂点tを初めて訪れる時刻
L = [-1]*(n+1)  # L[t] = 頂点tを最後に訪れる時刻
for i,t in enumerate(tour):
    if F[t] == -1:
        F[t] = i+1
    L[t] = i+1

N = len(tour)
B_odd = BIT([0]*(N//2+3))
B_even = BIT([0]*(N//2+3))

for _ in range(m):
    X = LI()
    if X[0] == 1:
        x,val = X[1:]
        f = F[x]
        l = L[x]
        if f % 2 == 1:
            B_odd.update((f+1)//2,val)
            B_odd.update((l+1)//2+1,-val)
            B_even.update((f+1)//2,-val)
            B_even.update((l+1)//2,val)
        else:
            B_even.update(f//2,val)
            B_even.update(l//2+1,-val)
            B_odd.update(f//2+1,-val)
            B_odd.update(l//2+1,val)
    else:
        x = X[1]
        ans = A[x]
        f = F[x]
        if f % 2 == 0:
            ans += B_even.query(f//2)
        else:
            ans += B_odd.query((f+1)//2)
        print(ans)
