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.
class BIT():
    """区間加算、一点取得クエリをそれぞれO(logN)で応えるデータ構造を構築する
    add: 区間[begin, end)にvalを加える
    get_val: i番目(0-indexed)の値を求める
    """
    def __init__(self, n):
        self.n = n
        self.bit = [0] * (n + 1)

    def get_val(self, i):
        i = i + 1
        s = 0
        while i <= self.n:
            s += self.bit[i]
            i += i & -i
        return s

    def _add(self, i, val):
        while i > 0:
            self.bit[i] += val
            i -= i & -i

    def add(self, i, j, val):
        self._add(j, val)
        self._add(i, -val)


from collections import deque
import sys
input = sys.stdin.readline


def eular_tour(tree: list, root: int):
    n = len(tree)
    res = []
    begin = [-1] * n
    end = [-1] * n
    visited = [False] * n
    visited[root] = True
    q = deque([root])
    while q:
        pos = q.pop()
        res.append(pos)
        end[pos] = len(res)
        if begin[pos] == -1:
            begin[pos] = len(res) - 1
        for next_pos in tree[pos]:
            if visited[next_pos]:
                continue
            else:
                visited[next_pos] = True
                q.append(pos)
                q.append(next_pos)

    return res, begin, end

n, q = map(int, input().split())
init_cost = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(n-1)]
query = [list(map(int, input().split())) for i in range(q)]

tree = [[] for i in range(n)]
for i in range(n-1):
    a, b = info[i]
    a -= 1
    b -= 1
    tree[a].append(b)
    tree[b].append(a)

res, begin, end = eular_tour(tree, 0)
even_res = []
odd_res = []
for i in range(len(res)):
    if i % 2 == 0:
        even_res.append(res[i])
    else:
        odd_res.append(res[i])

even_bit = BIT(len(even_res))
odd_bit = BIT(len(odd_res))

for i in range(q):
    if query[i][0] == 1:
        _, pos, cost = query[i]
        pos -= 1
        if begin[pos] % 2 == 0:
            even_bit.add(begin[pos] // 2, (end[pos] + 1) // 2, cost)
            odd_bit.add(begin[pos] // 2, end[pos] // 2, -cost)    
        else:
            odd_bit.add(begin[pos] // 2, end[pos] // 2, cost) 
            even_bit.add((begin[pos] + 1) // 2, end[pos] // 2, -cost) 
    else:
        _, pos = query[i]
        pos -= 1
        if begin[pos] % 2 == 0:
            ans = even_bit.get_val(begin[pos] // 2)
        else:
            ans = odd_bit.get_val(begin[pos] // 2)
        print(ans + init_cost[pos])