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,math
from bisect import bisect_left , bisect_right 
from heapq import heappush, heappop, heapify
from collections import defaultdict,Counter,deque
from functools import lru_cache
from itertools import permutations,combinations,product


def rd(): return sys.stdin.readline().strip()
def rdl(typ,sep=" "): return list(map(typ, rd().split(sep)))
def wt(x,sep="\n") : sys.stdout.write(str(x) + sep)    # string / num
def wtBoolUp(x): wt("YES" if x==True else "NO")  # True = YES/ False =NO
def wtBoolLow(x): wt("Yes" if x==True else "No")  # True = Yes/ False =No
def wtlArr(arr,sep=" "): sys.stdout.write(sep.join(map(str,arr)) + "\n") if arr else None  # Print arr in single line
def wtlsArr(arr): sys.stdout.write("\n".join(map(str,arr)) + "\n") if arr else None  # Print arr in mult lines
def wtlsArrArr(arr):    # print Arrays in multiple lines
    for a in arr: wtlArr(a)

# for dfs use this and use 'yield' during dfs and at last
from types import GeneratorType
def bootstrap(f, stack=[]):              
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc

# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

INF = float("inf") 
mod = 10**9 + 7    

def binPow(a,b,mod) :
    res = 1
    while b :
        if b % 2: 
            res = res * a % mod
        a = a * a % mod
        b //= 2
    return res

def invMod(x,mod): return pow(x,mod-2,mod)      

def getFacts(n,mod):   # O(n)
    fact = [1]*(n+1)
    for i in range(2,n+1): fact[i] = (i*fact[i-1])%mod
    return fact

def nCr(n, r, fact, mod) :  # O(logMOD)
    num = fact[n]       # numerator
    den = (fact[r] * fact[n - r]) % mod   # denominator
    return (num * invMod(den, mod)) % mod

def lcm(num1,num2):
    hcf = math.gcd(num1,num2)
    lcm_ = (num1*num2)//hcf
    return lcm_

def sqrtFloat(num):  # req : https://codeforces.com/contest/1809/problem/B
    l, r = 0 , num
    res = 0
    while l <= r :
        mid = (l+r)//2
        if mid*mid <= num :
            res = mid
            l = mid + 1
        else : #number will be on l side
            r = mid-1
    
    return res + 0.1*(res*res != num)

def floor(a,b): return a//b
def ceil(a,b): return (a+b-1)//b

def prefixSum(arr):   # 0 at last of prefix sum
    pref = [0]*(len(arr)+1)
    for i in range(len(arr)): pref[i] = arr[i] + pref[i-1]
    return pref

def prefixXor(arr):   # 0 at last of prefix Xor
    pref = [0]*(len(arr)+1)
    for i in range(len(arr)): pref[i] = arr[i] ^ pref[i-1]
    return pref

def apNth(n, a=1, d=1) : return a+(n-1)*d
def apSum(n, a=1, d=1):  return (2*a+(n-1)*d)*n//2
def apSumRange(l, r, d=1) : return apSum((r-l+1)//d, l, d)

def hypot(p1,p2):
    return ((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)**0.5
def manhat(p1,p2):
    return abs(p2[0]-p1[0]) + abs(p2[1]-p1[1])

def comb(n,r):   # for small x otherwise TC higher
    res = 1
    for i in range(r) : res = res*(n-i)//(i+1)   # res*(n-i) % (i+1) == 0  always
    return res

def powerArr(base,n,mod):
    pwr = [1]*n
    for i in range(1,n):
        pwr[i] = (base*pwr[i-1]) % mod
    return pwr

def getClosest(num,sortArr,notTake=-INF,notTakeCnt=1):
    idx = bisect_left(sortArr,num)  # find closest to x , not take notTake
    closeArr = []
    for i in range(max(0,idx-2),min(len(sortArr),idx+3)) : # [idx-2,idx-1,idx,idx+1,idx+2]
        if notTakeCnt>0 and sortArr[i] == notTake:
            notTakeCnt -= 1
            continue
        closeArr.append(sortArr[i])
    return min(closeArr, key=lambda x:abs(x-num),default=-INF)

def group(arr, notTake=INF):  # grouping of similar elements
    n = len(arr)
    res = []
    i = 0
    while i < n:
        st = i
        while i+1 <n and arr[i] == arr[i+1] :
            i += 1
        if arr[st] != notTake:
            res.append([arr[st],st,i,i-st+1])
        i += 1
    return res

def dirnsRD() : return [(0,1),(1,0)]
def dirnsLU() : return [(0,-1),(-1,0)]
def dirns(): return dirnsRD() + dirnsLU()
def dirnsDiag(): return dirns() + [(1,1),(1,-1),(-1,1),(-1,-1)]
def chessDirns(): return [(-2,-1),(-1,-2),(1,-2),(2,-1),(2,1),(1,2),(-1,2),(-2,1)]

def cntBits(n): return bin(n).count("1")
def isRepSumP2(num, x): return cntBits(num) <= x <= num  # num in sum two's power in x moves ?
def binry(decimal): return bin(decimal).replace('0b', '')
def deciml(binary): return int(str(binary),2)
def printAllBin(arr):
    maxLen = len(binry(max(arr)))
    for x in arr:
        curr = binry(x)
        res = " ".join(list("0"*(maxLen-len(curr))+curr))
        wt( res + f"   <- {x}")

def c2i(ch,up=0): return ord(ch) - ord('A' if up else 'a')  # ch to integer
def i2c(n,up=0): return chr(ord('A' if up else 'a') + n)    # integer to ch

def setPrec(num, cnt): return round(num, cnt)
def flush(): sys.stdout.flush()
def clearCache(func): func.cache_clear()   # used to clear the lru cache for every new test case



# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
''' ॐॐ _/\_ हर हर महादेव _/\_ ॐॐ '''

# sys.setrecursionlimit(300_005)
# mod = 10**9 + 7


class Fenwick:
    def __init__(self, n):
        self.n = n + 1      # len of fenwick tree
        self.fenwickTree = [0]*self.n        # 1 indexed
    
    
    def query(self, i):    # sum of numbers from 1 to i(include)
        total = 0
        while i > 0: 
            total += self.fenwickTree[i]
            i -= ( i & -i )     # i & -i  => extract last set fenwickTree
        return total
    

    def update(self, i, amount):       # amount = newVal - prevVal
        while i < self.n:  # i < len of fenwick tree
            self.fenwickTree[i] += amount
            i += ( i & -i )


    def rangeQuery(self, l, r):  # [l,r] and l,r are 1 indexed
        return self.query(r) - self.query(l-1)
    

    def rangeUpdate(self, l, r, val): # [l,r] and l,r are 1 indexed
        self.update(l, val)
        self.update(r+1, -val)



class EulerTour3: 
    def __init__(self, n):
        self.adjList = [set() for _ in range(n)]
        self.start = [-1]*n
        self.end = [-1]*n
        self.level = [0]*n
        self.timer = 0   
        self.root = 0


    def addEdge(self, u, v):
        self.adjList[u].add(v)
        self.adjList[v].add(u)


    def work(self):
        self.dfs(self.root, -1)

    @bootstrap
    def dfs(self, root, par):
        # before go to adjacents mark the root pos
        self.timer += 1  # inc fro next pos
        self.start[root] = self.timer
        self.level[root] = self.level[par]^1

        for child in self.adjList[root]:
            if child == par:
                continue
            yield self.dfs(child, root)

        # after go to all adjacents mark the root pos 
        self.end[root] = self.timer
        yield



def solve():
    n,q = rdl(int)
    et = EulerTour3(n)
    vals = rdl(int)
    for _ in range(n-1):
        u,v = rdl(int)
        et.addEdge(u-1, v-1)
    
    ##  -----------------------------------------  
    
    et.work()
    fw = [Fenwick(10**5+10) for _ in range(2)]

    for _ in range(q):
        query = rdl(int)
        if query[0] == 1:
            typ, x, val = query 
            x -= 1
            s, e = et.start[x], et.end[x]
            fw[et.level[x]].rangeUpdate(s,e,val)
            fw[et.level[x]^1].rangeUpdate(s,e,-val)
        else:
            typ, x = query
            x -= 1
            s = et.start[x]
            res = fw[et.level[x]].query(s) + vals[x]
            wt(res)
    
    return 


# Don't forget the mod and recursion limit

solve()
