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
from math import inf
from collections import defaultdict
input = sys.stdin.readline 

def dfs(d, n):
    v = [0] * (n + 1)
    v[1] = 1 
    q = [1] 
    f = [i for i in range(n + 1)]
    while(q):
        a = q.pop(0) 
        for j in d[a]:
            if(not v[j]):
                v[j] = 1 
                f[j] = a
                q.append(j) 

    return f

n, m = map(int, input().split()) 
a = [0] + list(map(int, input().split())) 
d = defaultdict(list) 
for i in range(n - 1):
    u, v = map(int, input().split()) 
    d[u].append(v) 
    d[v].append(u) 
    
f = dfs(d, n) 
# print(f)
c = [0] * (n + 1) 
for i in range(m):
    l = list(map(int, input().split())) 
    if(len(l) == 3):
        c[l[1]] += l[2] 
    else:
        j = 0 
        u = l[1] 
        s = a[u]
        while(u != f[u]):
            if(j % 2):
                s -= c[u] 
            else:
                s += c[u] 
            u = f[u] 
            j += 1 
        if(j % 2):
            s -= c[u] 
        else:
            s += c[u]
        print(s)
