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.
def build_tree(tree, a, v, tl, tr):
    if tl == tr:
        tree[v] = a[tl]
    else:
        tm = (tl + tr) // 2
        build_tree(tree, a, v * 2, tl, tm)
        build_tree(tree, a, v * 2 + 1, tm + 1, tr)
        tree[v] = tree[v * 2] + tree[v * 2 + 1]


def tree_sum(tree, v, tl, tr, l, r):
    if l > r:
        return 0
    if l == tl and r == tr:
        return tree[v]
    tm = (tr + tl) // 2
    x = tree_sum(tree, v * 2, tl, tm, l, min(tm, r))
    y = tree_sum(tree, v * 2 + 1, tm + 1, tr, max(tm + 1, l), r)
    return x + y


def tree_update(tree, v, tl, tr, pos, new_val):
    if tl == tr:
        tree[v] += new_val
    else:
        tm = (tr + tl) // 2
        if pos <= tm:
            tree_update(tree, v * 2, tl, tm, pos, new_val)
        else:
            tree_update(tree, v * 2 + 1, tm + 1, tr, pos, new_val)

        tree[v] = tree[v * 2] + tree[v * 2 + 1]


def rqm(tree, v, tl, tr, l, r):
    if l > r:
        return 0
    if tl == l and tr == r:
        return tree[v]
    tm = (tl + tr) // 2
    m1 = rqm(tree, v * 2, tl, tm, l, min(r, tm))
    m2 = rqm(tree, v * 2 + 1, tm + 1, tr, max(tm + 1, l), r)

    return m1 + m2


def dfs_col(g, amounts, depth, parents, v, pr):
    amounts[v] = 1
    parents[v] = pr
    for to in g[v]:
        if to == pr:
            continue

        depth[to] = depth[v] + 1
        dfs_col(g, amounts, depth, parents, to, v)
        amounts[v] += amounts[to]


def dfs_heavy_light(A, poses, top, g, amounts, v, pr, tp):
    top[v] = tp
    poses[v] = len(A)
    A.append(v)
    ind = -1
    for to in g[v]:
        if to == pr:
            continue
        if ind == -1 or amounts[to] > amounts[ind]:
            ind = to

    if ind == -1:
        return

    dfs_heavy_light(A, poses, top, g, amounts, ind, v, tp)
    for to in g[v]:
        if to == pr or to == ind:
            continue
        dfs_heavy_light(A, poses, top, g, amounts, to, v, to)


def solve():
    n, m = [int(i) for i in input().split()]
    vals = [int(i) for i in input().split()]
    g = [[] for i in range(n)]
    edges = []
    parents = [-1 for i in range(n)]
    amounts = [0 for i in range(n)]
    depth = [0 for i in range(n)]
    poses = [0 for i in range(n)]
    top = [-1 for i in range(n)]
    A = []

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

    dfs_col(g, amounts, depth, parents, 0, -1)
    dfs_heavy_light(A, poses, top, g, amounts, 0, -1, 0)

    tree = [0 for i in range(4 * n)]

    for _ in range(m):
        q = [int(i) for i in input().split()]
        if q[0] == 1:
            x, v = q[1], q[2]
            x -= 1
            if depth[x] % 2:
                v *= -1
            tree_update(tree, 1, 0, n - 1, poses[x], v)

        else:
            x = q[1]
            x -= 1
            y = 0
            sm = 0
            mul = 1
            vert = x
            if depth[x] % 2:
                mul = -1
            while True:
                u = top[x]
                v = top[y]
                if depth[u] < depth[v]:
                    u, y = y, u
                    x, y = y, x
                if u == v:
                    sm += rqm(tree, 1, 0, n - 1, min(poses[x], poses[y]), max(poses[x], poses[y]))
                    break
                else:
                    sm += rqm(tree, 1, 0, n - 1, poses[u], poses[x])
                    x = parents[u]

            sm *= mul
            print(sm + vals[vert])


solve()
