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
input = sys.stdin.buffer.readline
import heapq 


class LazySegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a+b):
        """initialize the lazy segment tree with data"""
        self._default = default
        self._func = func

        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()
        self._lazy = [0] * (2 * _size)

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __len__(self):
        return self._len

    def _push(self, idx):
        """push query on idx to its children"""
        # Let the children know of the queries
        q, self._lazy[idx] = self._lazy[idx], 0

        self._lazy[2 * idx] += q
        self._lazy[2 * idx + 1] += q
        self.data[2 * idx] += q
        self.data[2 * idx + 1] += q

    def _update(self, idx):
        """updates the node idx to know of all queries applied to it via its ancestors"""
        for i in reversed(range(1, idx.bit_length())):
            self._push(idx >> i)

    def _build(self, idx):
        """make the changes to idx be known to its ancestors"""
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]
            idx >>= 1

    def add(self, start, stop, value):
        """lazily add value to [start, stop)"""
        start = start_copy = start + self._size
        stop = stop_copy = stop + self._size
        while start < stop:
            if start & 1:
                self._lazy[start] += value
                self.data[start] += value
                start += 1
            if stop & 1:
                stop -= 1
                self._lazy[stop] += value
                self.data[stop] += value
            start >>= 1
            stop >>= 1

        # Tell all nodes above of the updated area of the updates
        self._build(start_copy)
        self._build(stop_copy - 1)

    def query(self, start, stop, default=0):
        """func of data[start, stop)"""
        start += self._size
        stop += self._size

        # Apply all the lazily stored queries
        self._update(start)
        self._update(stop - 1)

        res = default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "LazySegmentTree({0})".format(self.data)
    
n, m = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
g = [[] for i in range(n+1)]
for i in range(n-1):
    u, v = [int(x) for x in input().split()]
    g[u].append(v)
    g[v].append(u)
times = [None for i in range(n+1)]
parent = [None for i in range(n+1)]
depth = [0 for i in range(n+1)]
H = [(0, 1)]
parent[1] = -1
curr = [1]
I = 0
while len(curr) > 0:
    x = curr[-1]
    if len(g[x]) > 0:
        y = g[x][-1]
        if parent[y] is not None:
            g[x].pop()
        else:
            curr.append(y)
            parent[y] = x
            depth[y] = (1+depth[x])
            heapq.heappush(H, (-1*depth[y], y))
    else:
        times[x] = I
        I+=1
        curr.pop()
time_ranges = [(float('inf'), -1*float('inf')) for i in range(n+1)]
while H > 0:
    d1, x = heapq.heappop(H)
    l, r = time_ranges[x]
    l, r = min(l, times[x]), max(r, times[x])
    time_ranges[x] = (l, r)
    if parent[x] != -1:
        y = parent[x]
        l1, r1 = time_ranges[y]
        l1, r1 = min(l1, l), max(r1, r)
        time_ranges[y] = (l1, r1)
odd_tree = LazySegmentTree(data = [0 for i in range(n+1)])
even_tree = LazySegmentTree(data = [0 for i in range(n+1)])
Q = []
for i in range(m):
    query = [int(x) for x in input().split()]
    if query[0]==1:
        t, x, val = query
        parity = depth[x] % 2
        l, r = time_ranges[x]
        if parity==0:
            even_tree.add(l, r+1, val)
            odd_tree.add(l, r+1, -1*val)
        else:
            even_tree.add(l, r+1, -1*val)
            odd_tree.add(l, r+1, val)
    else:
        t, x = query
        parity = depth[x] % 2
        x1 = times[x]
        value = A[x-1]
        if parity==0:
            entry = even_tree.query(x1, x1+1)
        else:
            entry = odd_tree.query(x1, x1+1)
        sys.stdout.write(f'{value+entry}\n')