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
def propagate(a, tree, att, root, n):
	#print("Cheguei em", root, "Em procura de", n)
	#print(a)
	#print(tree)
	if(root == n):
	#	print("Achei !")
		return a[n-1]
	if(att[root-1] != 0):
		val = att[root-1]
		for node in tree[root-1]:
			a[node-1] += val
			att[node-1] += -val
	att[root-1] = 0
	for node in tree[root-1]:
		result = propagate(a, tree, att, node, n)
		if(type(result) == int):
			return result
	return False
			
n, m = list(map(int, input().split()))
sys.setrecursionlimit(max(1000,n+1))
a = list(map(int, input().split()))
tree = [[] for i in range(n)]
att = [0 for i in range(n)]
for _ in range(n-1):
	vi, vu = list(map(int, input().split()))
	tree[vi-1].append(vu)
for _ in range(m):
	check = list(map(int, input().split()))
	if(len(check) == 3):
		x = check[1]
		val = check[2]
		a[x-1] += val
		att[x-1] += -val
	else:
		print(propagate(a, tree, att, 1, check[1]))