#include <bits/stdc++.h>
using namespace std;
#define ll          long long
#define vl          vector<ll>
#define vi          vector<int>
#define pi          pair<int,int>
#define pl          pair<ll,ll>
#define all(a)      a.begin(),a.end()
#define mem(a,x)    memset(a,x,sizeof(a))
#define pb          push_back
#define mp          make_pair
#define F           first
#define S           second
#define endl 		"\n"
#define rep(i,a,b)  for(int i=a;i<b;i++)
#define fast_io     std::ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
#define trace(...) ZZ(#__VA_ARGS__, __VA_ARGS__);
template <typename Arg1> void ZZ(const char* name, Arg1&& arg1) {std::cerr << name << " = " << arg1 << endl;}
template <typename Arg1, typename... Args>void ZZ(const char* names, Arg1&& arg1, Args&&... args)
{
	const char* comma = strchr(names + 1, ',');
	std::cerr.write(names, comma - names) << " : " << arg1;
	ZZ(comma, args...);
}
const int maxn = 2e5 + 7;
int n, m;
vi a(maxn), dep(maxn, 0), vis(maxn, 0), beg(maxn, 0), en(maxn, 0);
vi adj[maxn];
int t = 1;
void dfs(int u, int d) {
	if (vis[u])return;
	vis[u]++;
	beg[u] = t;
	dep[u] = d;
	t++;
	for (auto v : adj[u]) {
		dfs(v, d + 1);
	}
	en[u] = t;
}
ll BIT[maxn];
ll query(int x) {
	ll ret = 0;
	while (x > 0) {
		ret += BIT[x];
		x -= (x & -x);
	}
	return ret;
}
void sum(int x, ll val) {
	while (x <= n) {
		BIT[x] += val;
		x += (x & -x);
	}
}
void solve() {
	cin >> n >> m;
	rep(i, 1, n + 1)cin >> a[i];
	rep(i, 0, n - 1) {
		int u, v;
		cin >> u >> v;
		adj[u].pb(v);
		adj[v].pb(u);
	}
	dfs(1, 0);
	rep(i, 0, m) {
		int x;
		cin >> x;
		if (x == 1) {
			int k, val;
			cin >> k >> val;
			if (dep[k] % 2)val *= -1;
			sum(beg[k], val);
			sum(en[k] + 1, -val);
		}
		else {
			int k;
			cin >> k;
			ll val = query(k);
			if (dep[k] % 2)val *= -1;
			cout << a[k] + val << endl;
		}
	}
}
int main() {
	fast_io;
	int t = 1;
	// cin>>t;
	while (t--) {
		solve();
	}
	// cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
	return 0;
}


#include <bits/stdc++.h>
#include<algorithm>
using namespace std;
#define Get(x,y) scanf("%I64d%I64d",&x,&y);
#define get(x) scanf("%I64d",&x);
#define f(i,a,b) for(int i=a;i<b;i++)
#define f_(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define pb push_back
#define maxm(a,b) a=max(a,b);
#define minm(a,b) a=min(a,b);
#define S second
#define F first
const int N=2e5+9;
ll b[N],a[N],at[N],n,m,x,y,tvn=262144,k=19,ct,cnt,p,dist[N],ans,r;
string s;
vector<ll> g[N];
map<ll,ll> z;
string binary(ll m,ll k){
	string g="";
	f(i,0,k){
		g+=char((m%2)+'0');
		m=m/2;
	}
	return g;}
void dfs(int x,int par,int dis){
	a[x]=cnt++,dist[x]=dis;
	f(i,0,g[x].size()){
		if(g[x][i]!=par) dfs(g[x][i],x,dis+1);
	}
	at[x]=cnt-1;
}
void update(int x,int val){
	s=binary(a[x],k),p=0,ct=tvn;
	f_(i,k-1,0){
		if(s[i]=='1'){
			p+=ct;
			z[p]+=val;
		}
		ct/=2;
	}
	s=binary(at[x]+1,k),p=0,ct=tvn;
	f_(i,k-1,0){
		if(s[i]=='1'){
			p+=ct;
			z[p]-=val;
		}
		ct/=2;
	}
}
ll solve(ll d){
	p=tvn*2,ct=tvn;
	s=binary(tvn*2-1-d,k),r=0;
	f_(i,k-1,0){
		if(s[i]=='1'){
			p-=ct;
			r+=z[p];
		}
		ct/=2;
	}
	return r;
}
int main(){
	Get(n,m);
	f(i,0,n) get(b[i+1]);
	f(i,0,n-1){
		Get(x,y);
		g[x].pb(y);
		g[y].pb(x);
	}
	dfs(1,0,0);
	f(i,0,m){
		get(x);
		if(x==1){
			Get(x,y);
			if(dist[x]%2==1) y=-y;
			update(x,y);
		}
		else{
			get(x);
			ans=solve(a[x]);
			if(dist[x]%2==0) ans=-ans;
			cout<<ans+b[x]<<endl;
		}
	}
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include<sstream>

using namespace std;
#define ll long long

ll t = 0;
vector<ll> g[200001], v;
map<ll, pair<ll, ll>> m;
map<ll, ll> m1;
ll level[200001];
pair<ll, ll> lazy[900000], st[900000];

void dfs(ll vtx, ll par, int l) {
    t++;
    ll r = t;
    level[vtx] = l;
    for (ll i : g[vtx]) {
        if (i != par) {
            dfs(i, vtx, l + 1);
        }
    }
    m[vtx] = {r, t};
    m1[r] = vtx;
}

void merge(ll i) {
    st[i].first = st[2 * i].first + st[2 * i + 1].first;
    st[i].second = st[2 * i].second + st[2 * i + 1].second;
}

void apply_lazy(ll i, ll l, ll r) {
    st[i].first += (r - l + 1) * lazy[i].first;
    st[i].second += (r - l + 1) * lazy[i].second;
    if (l != r) {
        lazy[2 * i].first += lazy[i].first, lazy[2 * i].second += lazy[i].second;
        lazy[2 * i + 1].first += lazy[i].first, lazy[2 * i + 1].second += lazy[i].second;
    }
    lazy[i].first = lazy[i].second = 0;
}

void update(ll i, ll l, ll r, ll ql, ll qr, ll val, ll odd) {
    apply_lazy(i, l, r);

    if (ql > r || qr < l) {
        return;
    }

    if (l >= ql && r <= qr) {
        if (odd) st[i].first += val;
        else st[i].second += val;
        if (l != r) {
            if (odd) {
                lazy[2 * i].first += val;
                lazy[2 * i + 1].first += val;
            } else {
                lazy[2 * i].second += val;
                lazy[2 * i + 1].second += val;
            }
        }
        return;
    }

    update(2 * i, l, (l + r) / 2, ql, qr, val, odd);
    update(2 * i + 1, (l + r) / 2 + 1, r, ql, qr, val, odd);

    merge(i);
}

ll find(ll i, ll l, ll r, ll qi) {
    apply_lazy(i, l, r);
    if (qi > r || qi < l) {
        return 0;
    }

    if (l == r && r == qi) {
        if (level[m1[l]] % 2) {
            return st[i].first;
        }
        return st[i].second;
    }

    auto x = find(2 * i, l, (l + r) / 2, qi);
    auto y = find(2 * i + 1, (l + r) / 2 + 1, r, qi);

    return x + y;
}

void make(ll i, ll l, ll r) {
    if (l == r) {
        ll lev = level[m1[l]];
        if (lev % 2) {
            st[i].first = v[m1[l] - 1];
        } else {
            st[i].second = v[m1[l] - 1];
        }
        return;
    }
    make(2 * i, l, (l + r) / 2);
    make(2 * i + 1, (l + r) / 2 + 1, r);

    merge(i);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    ll n, q;
    cin >> n >> q;
    v.resize(n);
    for (ll &i : v) {
        cin >> i;
    }
    for (ll i = 0, u, v; i < n - 1; i++) {
        cin >> u >> v;
        g[u].push_back(v), g[v].push_back(u);
    }

    dfs(1, 0, 0);
    make(1, 1, n);

    while (q--) {
        ll ty;
        cin >> ty;
        if (ty == 1) {
            int x, val;
            cin >> x >> val;
            ll lev = level[m1[x]];
            update(1, 1, n, m[x].first, m[x].second, val, lev % 2);
            update(1, 1, n, m[x].first, m[x].second, -val, 1 - (lev % 2));
        } else {
            int x;
            cin >> x;
            cout << find(1, 1, n, m[x].first) << "\n";
        }
    }

}


#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include<sstream>

using namespace std;
#define ll long long

ll t = 0;
vector<ll> g[200001], v;
map<ll, pair<ll, ll>> m;
map<ll, ll> val;
ll level[200001];
pair<ll, ll> lazy[900000], st[900000];

void dfs(ll vtx, ll par, int l) {
    t++;
    ll r = t;
    level[r] = l;
    for (ll i : g[vtx]) {
        if (i != par) {
            dfs(i, vtx, l + 1);
        }
    }
    m[vtx] = {r, t};
    val[r] = v[vtx - 1];
}

void merge(ll i) {
    st[i].first = st[2 * i].first + st[2 * i + 1].first;
    st[i].second = st[2 * i].second + st[2 * i + 1].second;
}

void apply_lazy(ll i, ll l, ll r) {
    st[i].first += (r - l + 1) * lazy[i].first;
    st[i].second += (r - l + 1) * lazy[i].second;
    if (l != r) {
        lazy[2 * i].first += lazy[i].first, lazy[2 * i].second += lazy[i].second;
        lazy[2 * i + 1].first += lazy[i].first, lazy[2 * i + 1].second += lazy[i].second;
    }
    lazy[i].first = lazy[i].second = 0;
}

void update(ll i, ll l, ll r, ll ql, ll qr, ll val, ll odd) {
    apply_lazy(i, l, r);

    if (ql > r || qr < l) {
        return;
    }

    if (l >= ql && r <= qr) {
        if (odd) st[i].first += val;
        else st[i].second += val;
        if (l != r) {
            if (odd) {
                lazy[2 * i].first += val;
                lazy[2 * i + 1].first += val;
            } else {
                lazy[2 * i].second += val;
                lazy[2 * i + 1].second += val;
            }
        }
        return;
    }

    update(2 * i, l, (l + r) / 2, ql, qr, val, odd);
    update(2 * i + 1, (l + r) / 2 + 1, r, ql, qr, val, odd);

    merge(i);
}

ll find(ll i, ll l, ll r, ll qi) {
    apply_lazy(i, l, r);
    if (qi > r || qi < l) {
        return 0;
    }

    if (l == r && r == qi) {
        if (level[l] % 2) {
            return st[i].first;
        }
        return st[i].second;
    }

    auto x = find(2 * i, l, (l + r) / 2, qi);
    auto y = find(2 * i + 1, (l + r) / 2 + 1, r, qi);

    return x + y;
}

void make(ll i, ll l, ll r) {
    if (l == r) {
        ll lev = level[l];
        if (lev % 2) {
            st[i].first = val[l];
        } else {
            st[i].second = val[l];
        }
        return;
    }
    make(2 * i, l, (l + r) / 2);
    make(2 * i + 1, (l + r) / 2 + 1, r);

    merge(i);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    ll n, q;
    cin >> n >> q;
    v.resize(n);
    for (ll &i : v) {
        cin >> i;
    }
    for (ll i = 0, u, v; i < n - 1; i++) {
        cin >> u >> v;
        g[u].push_back(v), g[v].push_back(u);
    }

    dfs(1, 0, 0);
    make(1, 1, n);

    while (q--) {
        ll ty;
        cin >> ty;
        if (ty == 1) {
            int x, va;
            cin >> x >> va;
            ll lev = level[m[x].first];
            update(1, 1, n, m[x].first, m[x].second, va, lev % 2);
            update(1, 1, n, m[x].first, m[x].second, -va, 1 - (lev % 2));
        } else {
            int x;
            cin >> x;
            cout << find(1, 1, n, m[x].first) << "\n";
        }
    }

}


#include<bits/stdc++.h>

#define Input                   freopen("in.txt","r",stdin)
#define Output                  freopen("out.txt","w",stdout)
#define ll                      long long int
#define ull                     unsigned long long int
#define pii                     pair<int,int>
#define pll                     pair<ll,ll>
#define sc                      scanf
#define scin(x)                 sc("%d",&(x))
#define scin2(x,y)              sc("%d %d",&(x),&(y))
#define scln(x)                 sc("%lld",&(x))
#define scln2(x,y)              sc("%lld %lld",&(x),&(y))
#define pf                      printf
#define all(a)                  (a.begin()),(a.end())
#define UNIQUE(X)               (X).erase(unique(all(X)),(X).end())
#define SORT_UNIQUE(c)          (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define ms(a,b)                 memset(a,b,sizeof(a))
#define pb(a)                   push_back(a)
#define mp                      make_pair
#define db                      double
#define EPS                     10E-10
#define ff                      first
#define ss                      second
#define sqr(x)                  (x)*(x)
#define vi                      vector<int>
#define vl                      vector<ll>
#define vii                     vector<vector<int> >
#define vll                     vector<vector<ll> >
#define DBG                     pf("HI\n")
#define MOD                     1000000007
#define CIN                     ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define RUN_CASE(t,T)           for(__typeof(t) t=1;t<=T;t++)
#define CASE(t)                 printf("Case %d: ",t)
#define CASEl(t)                printf("Case %d:\n",t)
#define intlimit                2147483690
#define longlimit               9223372036854775800
#define infinity                (1<<28)
#define gcd(a,b)                __gcd(a,b)
#define lcm(a,b)                (a)*(b)/gcd(a,b)
#define mxx                     123456789
#define PI                      2*acos(0.0)
#define rep(i,a,b)              for(__typeof(i) i=a;i<=b;i++)
#define rev(i,a,b)              for(__typeof(i) i=a;i>=b;i--)

using namespace std;
/**     toint, tostring, BigMod, Power , sieve, Primefactorize ,frequency in n!     **/
//ll toint(string s){ll n=0,k=1;for(int i=s.size()-1; i>=0; i--){n += ((s[i]-'0')*k);k*=10;}return n;}
//string tostring(ll x){string s="";while(x){s += (x%10)+'0';x/=10;}reverse(s.begin(),s.end());return s;}
//ll BigMod(ll a,ll b){if(b == 0)return 1%MOD;else if(b%2 == 0){ll temp=BigMod(a,b/2);return ((temp%MOD)*(temp%MOD))%MOD;}else{return ((a%MOD)*BigMod(a,b-1)%MOD)%MOD;}}
//ll Power(ll a,ll n){ll ret=1;for(ll i=1 ; i<=n ; i++)ret = ((ret%MOD)*(a%MOD))%MOD;return ret;}
//bool isPrime(ll n){for(ll i=2 ; i*i<=n ; i++){if(n%i == 0)return 0;}return 1;}
//vector<ll>Prime;
//bool mark[10000003];
//void sieve(ll n){ll i,j;mark[1]=1;for(i=4; i<=n; i+=2)mark[i]=1;Prime.push_back(2);for(i=3; i<=n; i+=2){if(!mark[i]){Prime.push_back(i);if(i*i<=n){for(j=i*i; j<=n; j+=(i*2))mark[j]=1;}}}}
//map<ll,ll>Factor;
//void Primefactorize(ll n){for(ll i=0; i<Prime.size() && Prime[i]*Prime[i]<=n; i++){if(n%Prime[i] == 0){while(n%Prime[i] == 0){Factor[Prime[i]]++;n/=Prime[i];}}}if(n>1){Factor[n]++;}}
//ll frequency(ll n,ll factor)/** Frequency of a factor in n! **/{ll cnt=0;while(n){cnt += (n/factor);n /= factor;}return cnt;}
/**     Order Set       **/
//#include <ext/pb_ds/assoc_container.hpp>
//using namespace __gnu_pbds;
//template<typename T> using orderset = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
//orderset<int> s ; //orderset<int>::iterator it ;
//orderset<int> X; //X.insert(1); //X.insert(2); //X.insert(4); //X.insert(8); //X.insert(16);
//cout<<*X.find_by_order(0)<<endl; // 2 //cout<<*X.find_by_order(2)<<endl; // 4 //cout<<*X.find_by_order(4)<<endl; // 16 //cout<<(end(X)==X.find_by_order(6))<<endl; // true
//cout<<X.order_of_key(-5)<<endl;  // 0 //cout<<X.order_of_key(1)<<endl;   // 0 //cout<<X.order_of_key(3)<<endl;   // 2 //cout<<X.order_of_key(4)<<endl;   // 2 //cout<<X.order_of_key(400)<<endl; // 5

/** Debugging Tool **/
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args)
{
    cerr << *it << " = " << a << endl;
    err(++it, args...);
}
///

inline int add(int a, int b) {a += b; return a >= MOD ? a - MOD : a;}
inline int sub(int a, int b) {a -= b; return a < 0 ? a + MOD : a;}
inline int mul(int a, int b) {return (ll) a * b % MOD;}
int Set(int N, int pos) {return  N = N | (1<<pos);}
int Reset(int N, int pos) {return  N = N & ~(1<<pos);}
bool Cheek(int N, int pos) {return  (bool)(N & (1<<pos));}

//string small = "abcdefghijklmnopqrstuvwxyz";
//string capital = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

///------------------Graph Moves-------------------
///const int fx[] = {+1,-1,+0,+0};
///const int fy[] = {+0,+0,+1,-1};
///const int fx[] = {+0,+0,+1,-1,-1,+1,-1,+1}; ///King's move
///const int fy[] = {-1,+1,+0,+0,+1,+1,-1,-1}; ///King's move
///const int fx[] = {-2,-2,-1,-1,+1,+1,+2,+2}; ///Knight's move
///const int fy[] = {-1,+1,-2,+2,-2,+2,-1,+1}; ///Knight's move

#define sz 400009
int tree[2][4*sz],lazy[2][4*sz];  ///tree[0]-for even level ; tree[1]-for odd level

void pushdown(int id,int node,int b,int e)
{
    tree[id][node] += lazy[id][node];
    if(b != e){
        lazy[id][node<<1] += lazy[id][node];
        lazy[id][1+(node<<1)] += lazy[id][node];
    }
    lazy[id][node] = 0;
}

void Update(int id,int node,int b,int e,int i,int j,int val)
{
    if(lazy[id][node] != 0)
        pushdown(id , node , b , e);
    if(b>j || e<i)
        return;
    if(b>=i && e<=j){
        tree[id][node] += val;
        if(b != e){
            lazy[id][node<<1] += val;
            lazy[id][1+(node<<1)] += val;
        }
        return;
    }
    int lft = node<<1;
    int rgt = 1+lft;
    int mid = (b+e)>>1;
    Update(id , lft , b , mid , i , j , val);
    Update(id , rgt , mid+1 , e , i , j , val);
    tree[id][node] = tree[id][lft]+tree[id][rgt];
}

int Query(int id,int node,int b,int e,int i,int j)
{
    if(b>j || e<i)
        return 0;
    if(lazy[id][node] != 0)
        pushdown(id , node , b , e);
    if(b>=i && e<=j)
        return tree[id][node];
    int lft = node<<1;
    int rgt = lft+1;
    int mid = (b+e)>>1;
    int p1 = Query(id , lft , b , mid , i , j);
    int p2 = Query(id , rgt , mid+1 , e , i , j);
    return p1+p2;
}

///graph part
int tim=0,stime[sz/2],edtime[sz/2],level[sz/2],vis[sz/2],ara[sz/2];
vi graph[sz/2];

void DFS(int u,int lv)
{
    vis[u] = 1;
    stime[u] = ++tim;
    level[u] = lv;
    for(auto v:graph[u]){
        if(!vis[v]){
            DFS(v , 1+lv);
        }
    }
    edtime[u] = ++tim;
}

void Solve(int t)
{
    int i,j,k,n,q,type,u,v,x,ans;
    scin2(n , q);
    rep(i,1,n)scin(ara[i]);
    for(i=1 ; i<n ; i++){
        scin2(u , v);
        graph[u].pb(v);
        graph[v].pb(u);
    }
    DFS(1 , 1);
    for(i=1 ; i<=q ; i++){
        scin(type);
        if(type == 1){
            scin2(u , x);
            if(level[u]%2 == 0){
                Update(0 , 1 , 1 , 2*n , stime[u] , edtime[u] , x);
                Update(1 , 1 , 1 , 2*n , stime[u] , edtime[u] , -x);
            }
            else{
                Update(0 , 1 , 1 , 2*n , stime[u] , edtime[u] , -x);
                Update(1 , 1 , 1 , 2*n , stime[u] , edtime[u] , x);
            }
        }
        else{
            scin(u);
            if(level[u]%2 == 0)
                cout<<Query(0 , 1 , 1 , 2*n , stime[u] , stime[u])+ara[u]<<endl;
            else
                cout<<Query(1 , 1 , 1 , 2*n , stime[u] , stime[u])+ara[u]<<endl;
        }
    }
}

int main()
{
    int t,T;
    T = 1;
//    scin(T);
    RUN_CASE(t,T)
    {
        Solve(t);
    }
    return 0;
}


// 5 5
// 1 2 1 1 2
// 1 2
// 1 3
// 2 4
// 2 5
// 1 2 3
// 1 1 2
// 2 1
// 2 2
// 2 4

// 3
// 3
// 0

// (1 ≤ n, m ≤ 200000)
// (1 ≤ ai ≤ 1000)
// 1 ≤ x ≤ n, 1 ≤ val ≤ 1000.

/*#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;*/
#include<algorithm>
#include <bits/stdc++.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include<ctype.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define S second
#define F first
#define vi vector<ll>
#define pii pair<ll,ll>
#define bc __builtin_popcountll
#define vvi vector<vi>
#define vpii vector<pair<ll,ll>>
#define mll unordered_map<ll,ll>
#define INF LONG_LONG_MAX
#define NINF LONG_LONG_MIN
#define fo(i,a,b) for(ll i=a;i<=b;i++)
#define f(i,n) for(ll i=0;i<n;i++)
#define f1(i,n) for(ll i=1;i<=n;i++)
#define fb(i,n) for(ll i=n-1;i>=0;i--)
#define fb1(i,n) for(ll i=n;i>0;i--)
#define endd cout<<'\n';
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define fr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define CASES  ll t;cin>>t;while(t--)
typedef long long ll;
typedef unsigned long long ull;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
//typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;
//*X.find_by_order()
//X.order_of_key()
struct cmp
{
    bool operator() (ll a,ll b){
        return (a>b);
    }
};
ll ceil(const ll &a, const ll &b)
{
    if(a%b == 0)
        return a/b;
    return a/b +1;
}
ll mod=1000000007;
const ll N=200005;

ll Sum(ll BIT[],ll index)
{
    ll sum = 0;
    index = index + 1;
    while (index>0)
    {
        sum += BIT[index];
        index -= index & (-index);
    }
    return sum;
}
void update(ll BIT[],ll n,ll index,ll val)
{
    index = index + 1;
    while (index <= n)
    {
        BIT[index] += val;
        index += index & (-index);
    }
}
ll *construct(ll arr[],ll n)
{
  ll *BIT=new ll[n+1];
  for (ll i=1;i<=n; i++)
    BIT[i] = 0;
  for (ll i=0; i<n; i++)
    update(BIT,n,i,arr[i]);
  return BIT;

}
ll a[N],in[N],out[N],ft[2*N],lvl[N],timer=1;
vi adj[N];
void dfs(ll u,ll p,ll d=0)
{
    in[u]=timer;
    ft[timer]=u;
    timer++;
    lvl[u]=d%2;
    for(ll v : adj[u])
    {
        if(v!=p)
        {
            dfs(v,u,d+1);
        }
    }
    out[u]=timer;
    ft[timer]=u;
    timer++;
}
int main()
{
fast;
#ifndef ONLINE_JUDGE
    freopen("input.in", "r", stdin);
    freopen("error.in", "w", stderr);
    freopen("output.in", "w", stdout);
#endif
    ll n,m;
    cin>>n>>m;
    f1(i,n)
    {
        cin>>a[i];
    }
    f(i,n-1)
    {
        ll x,y;
        cin>>x>>y;
        adj[x].pb(y);
        adj[y].pb(x);
    }
    dfs(1,0);
    ll bit[2*n];
    clr(bit);
    ll *BIT=construct(bit,2*n);
    // cout<<"in\n";
    // f1(i,n)
    // {
    //     cout<<in[i]<<' ';
    // }
    // endd;
    // cout<<"out\n";
    // f1(i,n)
    // {
    //     cout<<out[i]<<' ';
    // }
    // endd;
    // cout<<"ft\n";
    // f1(i,2*n)
    // {
    //     cout<<ft[i]<<' ';
    // }
    while(m--)
    {
        ll x;
        cin>>x;
        if(x==1)
        {
            ll node,val;
            cin>>node>>val;
            if(lvl[node])
            {
                val=-val;
            }
            update(BIT,2*n,in[node],val);
            update(BIT,2*n,out[node]+1,-val);
        }
        else
        {
            ll node;
            cin>>node;
            ll ans=Sum(BIT,in[node]);
            if(lvl[node])
            {
                ans=-ans;
            }
            ans+=a[node];
            cout<<ans;
            endd;
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define S second
#define F first
#define f(i,n) for(int i=0;i<n;i++)
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define vi vector<int>
#define pii pair<int,int>

const int N = 2e5 + 10;
vi g[N];
int a[N];
int n,q;
int f[N];

void add(int id,int val)
{
    for(;id<N;id+=(id&-id)) f[id]+=val;
}

int sum(int x)
{
    int res = 0;
    for(;x>0;x-=(x&-x)) res+=f[x];
    return res;
}

int tin[N];
int tout[N];
bool h[N];
int timer = 1;

void dfs(int node,int par = -1,int dep = 0)
{
    h[node] = dep;

    tin[node] = tout[node] = timer++;

    for(auto x : g[node])
      if( x != par) dfs(x,node,dep^1),tout[node] = tout[x];

}

signed main()
{
    fast;

    cin >> n >> q;

    f(i,n) cin >> a[i+1];

    int u,v,x;

    f(i,n-1)
    {
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }

    dfs(1);

    f(i,q)
    {
        cin >> x >> u;

        if(x == 1)
        {
            cin >> v;

            if(h[u]) v*=-1;
            add(tin[u],v);
            add(tout[u]+1,-v);
        }
        else
        {
            int res = sum(tout[u]);

            if(h[u]) res=-res;

            res+=a[u];

            cout << res << '\n';
        }

    }
}


#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define S second
#define F first
#define f(i,n) for(int i=0;i<n;i++)
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define vi vector<int>
#define pii pair<int,int>

const int N = 2e5 + 10;
vi g[N];
int a[N];
int n,q;
int f[N];

void add(int id,int val)
{
    for(;id<N;id+=(id&-id)) f[id]+=val;
}

int sum(int x)
{
    int res = 0;
    for(;x>0;x-=(x&-x)) res+=f[x];
    return res;
}

int tin[N];
int tout[N];
bool h[N];
int timer = 1;

void dfs(int node,int par = -1,int dep = 0)
{
    h[node] = dep;

    tin[node] = tout[node] = timer++;

    for(auto x : g[node])
      if( x != par) dfs(x,node,dep^1),tout[node] = tout[x];

}

signed main()
{
    fast;

    cin >> n >> q;

    f(i,n) cin >> a[i+1];

    int u,v,x;

    f(i,n-1)
    {
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }

    dfs(1);

    f(i,q)
    {
        cin >> x >> u;

        if(x == 1)
        {
            cin >> v;

            if(h[u]) v*=-1;
            add(tin[u],v);
            add(tout[u]+1,-v);
        }
        else
        {
            int res = sum(tin[u]);

            if(h[u]) res=-res;

            res+=a[u];

            cout << res << '\n';
        }

    }
}


#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define MOD 1000003
#define EPS 1e-10

using namespace std;

typedef long long ll;
typedef pair<int,int> pii;

const int N = 200002;
int tree[4*N], inTime[N], outTime[N], t, revTime[N], arr[N], level[N];
pii lazy[4*N];
vector<int> adjList[N];

void dfs(int node, int parent, int l) {
    inTime[node] = ++t;
    revTime[t] = node;
    level[node] = l;
    for(int ch : adjList[node])
        if(ch != parent)
            dfs(ch, node, l+1);
    outTime[node] = t;
}

void propagate_lazy(int pos, int l, int r) {
    if(l == r) {
        int lev = level[revTime[l]];
        if(lev & 1)
            tree[pos] += lazy[pos].s;
        else
            tree[pos] += lazy[pos].f;
        lazy[pos] = {0, 0};
    } else {
        lazy[pos<<1].f += lazy[pos].f;
        lazy[pos<<1|1].f += lazy[pos].f;
        lazy[pos<<1].s += lazy[pos].s;
        lazy[pos<<1|1].s += lazy[pos].s;
        lazy[pos] = {0, 0};
    }
}

void build(int pos, int l, int r) {
    if(l == r) {
        tree[pos] = arr[revTime[l]];
        return;
    }
    int mid = (l+r)>>1;
    build(pos<<1, l, mid);
    build(pos<<1|1, mid+1, r);
}

void update(int pos, int l, int r, int qLow, int qHigh, pii val) {
    propagate_lazy(pos, l, r);
    if(l > qHigh || r < qLow)
        return;
    if(l>=qLow &&  r<= qHigh) {
        lazy[pos] = val;
        propagate_lazy(pos, l, r);
        return;
    }
    int mid = (l+r)>>1;
    update(pos<<1, l, mid, qLow, qHigh, val);
    update(pos<<1|1, mid+1, r, qLow, qHigh, val);
}

int get(int pos, int l, int r, int x) {
    propagate_lazy(pos, l, r);
    if(l > x || r < x)
        return -1e9;
    if(l==r)
        return tree[pos];
    int mid = (l+r)>>1;
    return max(get(pos<<1, l, mid, x), get(pos<<1|1, mid+1, r, x));
}

int main() {
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i =1;i<=n;i++)
        scanf("%d",&arr[i]);
    for(int i= 1;i<n;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        adjList[x].pb(y);
        adjList[y].pb(x);
    }
    dfs(1, 0, 0);
    build(1, 1, n);
    while(m--) {
        int x;
        scanf("%d",&x);
        if(x == 1) {
            int v;
            scanf("%d%d",&x, &v);
            int lev = level[x];
            pii add;
            if(lev & 1)
                add = {-v, v};
            else
                add = {v, -v};
            update(1, 1, n, inTime[x], outTime[x], add);
        } else {
            scanf("%d",&x);
            printf("%d\n", get(1, 1, n, inTime[x]));
        }
    }
    return 0;
}


//Bismillahir Rahmanir Rahim
#include<bits/stdc++.h>
using namespace std;
int a[200009],tym=0,st[200009],en[200009],ans;
int val[1000009],lz[1000009][2],lvl[200009];
vector<int>adj[200009];
void dfs(int u,int par)
{
    tym++;
    st[u]=tym;
    lvl[st[u]]=lvl[st[par]]^1;
    int sz=adj[u].size();
    for(int i=0;i<sz;i++)
    {
        int v=adj[u][i];
        if(v==par)continue;
        dfs(v,u);
    }
    en[u]=tym;

}
void update(int pos,int s,int e,int typ)
{
    if(s==e)
    {
        if(typ==lvl[s])
        {
            val[s]+=lz[pos][typ];
        }
        lz[pos][typ]=0;
        return;
    }
    lz[2*pos+1][typ]+=lz[pos][typ];
    lz[2*pos+2][typ]+=lz[pos][typ];
    lz[pos][typ]=0;
    return ;
}
void ad(int pos,int s,int e,int I,int J,int typ,int v)
{
    if(lz[pos][0]!=0)update(pos,s,e,0);
    if(lz[pos][1]!=0)update(pos,s,e,1);
    if(s==I && e==J)
    {
        lz[pos][typ]+=v;
        lz[pos][typ^1]-=v;
        return ;
    }
    int mid=(s+e)>>1;
    if(J<=mid)
    {
          ad(2*pos+1,s,mid,I,J,typ,v);
    }
    else if(I>mid)
    {
         ad(2*pos+2,mid+1,e,I,J,typ,v);
    }
    else
    {
        ad(2*pos+1,s,mid,I,mid,typ,v);
        ad(2*pos+2,mid+1,e,mid+1,J,typ,v);

    }
}
int query(int pos,int s,int e,int idx)
{
    if(lz[pos][0]!=0)update(pos,s,e,0);
    if(lz[pos][1]!=0)update(pos,s,e,1);
    if(s==e)return val[s];
    int mid=(s+e)>>1;
    if(idx<=mid)
        return query(2*pos+1,s,mid,idx);
    return query(2*pos+2,mid+1,e,idx);
}
main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=1;i<n;i++)
    {  int t1,t2;
        scanf("%d%d",&t1,&t2);
        adj[t1].push_back(t2);
        adj[t2].push_back(t1);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++)
    {
        val[st[i]]=a[i];
    }
    while(m--)
    {
        int typ,node,man;
        scanf("%d%d",&typ,&node);
        if(typ==1)
        {
            scanf("%d",&man);
            ad(0,1,n,st[node],en[node],lvl[st[node]],man);

        }
        else
        {
            ans=query(0,1,n,st[node]);
            printf("%d\n",ans);
        }
    }
    return 0;
}


// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimization ("unroll-loops")

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define fo(i,n)             for(int i=0;i<n;i++)
#define nl                  "\n"
#define ff                  first
#define ss                  second
#define int                 long long
#define pb                  push_back
#define mp                  make_pair
#define vec(x)              vector<x>
#define matrix(x)           vector<vector<x>>
#define sz(x)               (int)x.size()
#define mem(a,b)            memset(a, b, sizeof a)
#define vii                 vector<pair<int,int>>
#define pii                 pair<int,int>
#define vi                  vector<int>
#define mii                 map<int,int>
#define uii                 unordered_map<int,int,custom_hash>
#define pqb                 priority_queue<int>
#define pqs                 priority_queue<int,vi,greater<int> >
#define gcd(a,b)            __gcd(a,b)
#define lcm(a,b)            (a*(b/gcd(a,b)))
#define setbits(x)          __builtin_popcountll(x)
#define zrobits(x)          __builtin_ctzll(x)
#define mod                 1000000007
#define MOD                 998244353
#define inf                 1e18
#define ps(x,y)             fixed<<setprecision(y)<<x
#define mk(arr,n,type)      type *arr=new type[n];
#define w(x)                int x; cin>>x; while(x--)
#define all(v)              v.begin(),v.end()
#define rep(i,begin,end)    for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define len(s)              s.length()

#define watch(x)            cout << #x << " = " << x << endl

#define deb(...) cerr << "[" << #__VA_ARGS__ << "] : [", DBG(__VA_ARGS__)
void DBG() { cerr << "]\n";}
template<typename T, typename ...Args> void DBG(T first, Args... args)
{cerr << first; if(sizeof...(args))cerr<<", "; DBG(args...); }

mt19937                     rng(chrono::steady_clock::now().time_since_epoch().count());

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds; //for storing unique elements
typedef tree<int , null_type , less_equal<int> , rb_tree_tag , tree_order_statistics_node_update> ordered_set; //for repeating elements

int power(int a,int b,int m=mod)
{int ans=1;while(b>0){if(b&1)ans=(ans*a)%m;a=(a*a)%m;b>>=1;}
return ans;}

void babuBhaiya()
{
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
}

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

const int N = 2e5+100;
const double pi = acos(-1);

/*/-----------------------Modular Arithmetic---------------/*/
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
/*/-----------------------------Code begins----------------------------------/*/

struct BIT{

    int N;
    vector<int> bit;

    void init(int n){
        N = n;
        bit.assign(n + 1, 0);
    }

    void update(int idx, int val){
        while(idx <= N){
            bit[idx] += val;
            idx += idx & -idx;
        }
    }

    void updateMax(int idx, int val){
        while(idx <= N){
            bit[idx] = max(bit[idx], val);
            idx += idx & -idx;
        }
    }

    int pref(int idx){
        int ans = 0;
        while(idx > 0){
            ans += bit[idx];
            idx -= idx & -idx;
        }
        return ans;
    }

    int rsum(int l, int r){
        return pref(r) - pref(l - 1);
    }

    int prefMax(int idx){
        int ans = -2e9;
        while(idx > 0){
            ans = max(ans, bit[idx]);
            idx -= idx & -idx;
        }
        return ans;
    }
};

BIT bit;

vi adj[N];
int level[N], in[N], out[N], timer;

void dfs(int node, int par, int lvl){
    level[node] = lvl;
    in[node] = ++timer;
    for(int x : adj[node]){
        if(x != par){
            dfs(x,node,lvl+1);
        }
    }
    out[node] = timer;
}

void solve(){

    int n,m; cin>>n>>m;
    int arr[n+1];
    for(int i = 1;i<=n;i++) cin>>arr[i];
    bit.init(n+100);
    fo(i,n-1){
        int a,b; cin>>a>>b;
        adj[a].pb(b);
        adj[b].pb(a);
    }
    dfs(1,0,0);
    while(m--){
        int type, x; cin>>type>>x;
        if(type == 1){
            int val; cin>>val;
            if(level[x]&1) val = -val;
            bit.update(in[x],val);
            bit.update(out[x]+1,-val);
        }
        else{
            int val = bit.pref(in[x]);
            if(level[x]&1) val = -val;
            cout<<arr[x] + val<<"\n";
        }
    }
}

int32_t main()
{
    babuBhaiya();

    int t;

    t = 1;
    //cin>>t;

    while(t--){
        solve();
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

const int N = 1e6 + 5;

int bit[N][2];
int beg[N], endd[N], arri[N], lvl[N];
vector<int> v[N];
int tim = 0;

void dfs(int i, int par, int l) {
	arri[tim++] = i;
	lvl[i] = l % 2;
	beg[i] = tim;
	for(auto j : v[i]) {
		if(j != par) {
			dfs(j , i , l + 1);
		}
	}
	endd[i] = tim;
}

void update(int pos , int l, int val) {
	for(pos ; pos < N ; pos += pos&-pos)
		bit[pos][l] += val;
}
int pre(int pos ,int l) {
	int ret = 0;
	for(pos ; pos > 0 ; pos -= pos & -pos)
		ret += bit[pos][l];
	return ret;
}

int main() {
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	int n , m ; cin >> n >> m;
	int val[n + 1];
	for(int i = 1; i <= n ; i ++ ) {
		cin >> val[i];
	}
	for(int i = 0; i < n - 1 ;i ++ ) {
		int x , y; cin >> x >> y;
		v[x].push_back(y);
		v[y].push_back(x);
	}
	dfs(1 ,-1 ,1);

	while(m--){
		int x ; cin >> x;
		if(x == 1) {
			int pos , value;
			cin >> pos >> value;
			int l = lvl[pos];
			update(beg[pos] , l , value);
			update(endd[pos] + 1 , l , -1*value);
			update(beg[pos] , l^1 , -1*value);
			update(endd[pos] + 1, l^1 , value);
		} else {
			int pos ; cin >> pos;
			cout << val[pos] + pre(beg[pos] ,lvl[pos]) << '\n';
		}
	}
}


#include<bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5;

int bit[N][2];
int beg[N], endd[N], arri[N], lvl[N];
vector<int> v[N];
int tim = 0;

void dfs(int i, int par, int l) {
	arri[tim++] = i;
	lvl[i] = l % 2;
	beg[i] = tim;
	for(auto j : v[i]) {
		if(j != par) {
			dfs(j , i , l + 1);
		}
	}
	endd[i] = tim;
}

void update(int pos , int l, int val) {
	for(pos ; pos < N ; pos += pos&-pos)
		bit[pos][l] += val;
}
int pre(int pos ,int l) {
	int ret = 0;
	for(pos ; pos > 0 ; pos -= pos & -pos)
		ret += bit[pos][l];
	return ret;
}

int main() {
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	int n , m ; cin >> n >> m;
	int val[n + 1];
	for(int i = 1; i <= n ; i ++ ) {
		cin >> val[i];
	}
	for(int i = 0; i < n - 1 ;i ++ ) {
		int x , y; cin >> x >> y;
		v[x].push_back(y);
		v[y].push_back(x);
	}
	dfs(1 ,-1 ,1);

	while(m--){
		int x ; cin >> x;
		if(x == 1) {
			int pos , value;
			cin >> pos >> value;
			int l = lvl[pos];
			update(beg[pos] , l , value);
			update(endd[pos] + 1 , l , -1*value);
			update(beg[pos] , l^1 , -1*value);
			update(endd[pos] + 1, l^1 , value);
		} else {
			int pos ; cin >> pos;
			cout << val[pos] + pre(beg[pos] ,lvl[pos]) << '\n';
		}
	}
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define ff first
#define ss second
#define pll pair<ll,ll>
#define all(v) v.begin(),v.end()
#define mod 1000000007
#define maxn 200002

struct lazySegTree{
    int tree[8*maxn],lazy[8*maxn];

    void init(){
        memset(tree,0,sizeof tree);
        memset(lazy,0,sizeof lazy);
    }

    void update(ll pos, ll l, ll r, ll L, ll R, ll value){
        if(lazy[pos]){
            tree[pos]+=lazy[pos];
            if(l!=r){
                lazy[pos*2]+=lazy[pos];
                lazy[pos*2+1]+=lazy[pos];
            }
            lazy[pos]=0;
        }
        if(l>R || r<L || L>R) return;
        if(l>=L && r<=R){
            tree[pos]+=value;
            if(l!=r){
                lazy[pos*2]+=value;
                lazy[pos*2+1]+=value;
            }
            return;
        }
        ll mid=(l+r)/2;
        update(pos*2,l,mid,L,R,value);
        update(pos*2+1,mid+1,r,L,R,value);
        tree[pos]=tree[pos*2]+tree[pos*2+1];
    }

    ll query(ll pos, ll l, ll r, ll L, ll R){
        if(lazy[pos]){
            tree[pos]+=lazy[pos];
            if(l!=r){
                lazy[pos*2]+=lazy[pos];
                lazy[pos*2+1]+=lazy[pos];
            }
            lazy[pos]=0;
        }
        if(l>R || r<L){
            return 0;
        }
        if(l>=L && r<=R){
            return tree[pos];
        }
        ll mid=(l+r)/2;
        ll q1=query(pos*2,l,mid,L,R);
        ll q2=query(pos*2+1,mid+1,r,L,R);
        return q1+q2;
    }
};

int n,m,tim;
int st[maxn],en[maxn],depth[maxn],a[maxn];
vector <int> adj[maxn];
lazySegTree seg1,seg2;

void dfs(int u, int p, int d){
    depth[u]=d;
    st[u]=++tim;
    for(auto v:adj[u]){
        if(v!=p) dfs(v,u,d+1);
    }
    en[u]=++tim;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(),cout.tie();
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=0;i<n-1;i++){
        int u,v;
        cin>>u>>v;
        adj[u].pb(v);
        adj[v].pb(u);
    }
    dfs(1,0,0);
    seg1.init(),seg2.init();
    for(int i=1;i<=n;i++){
        seg1.update(1,1,tim,st[i],st[i],a[i]);
        seg2.update(1,1,tim,st[i],st[i],a[i]);
    }
    while(m--){
        int type,u,v,q;
        cin>>type;
        if(type==1){
            cin>>u>>v;
            if(depth[u]%2==0){
                seg1.update(1,1,tim,st[u],en[u],v);
                seg2.update(1,1,tim,st[u],en[u],-v);
            }
            else{
                seg1.update(1,1,tim,st[u],en[u],-v);
                seg2.update(1,1,tim,st[u],en[u],v);
            }
        }
        else{
            cin>>u;
            if(depth[u]%2==0) q=seg1.query(1,1,tim,st[u],st[u]);
            else q=seg2.query(1,1,tim,st[u],st[u]);
            cout<<q<<endl;
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
#define T (1 << 20)

int N, M, arr[200005], arr2[200005], parity[200005];
vector<int> adjList[200005];
ii intervals[200005];
map<int, int> getDirect;

class FenwickTree {
 private:
  vector<int> ft;

 public:
  FenwickTree(int n) { ft.assign(n + 1, 0); }
  int rsq(int b) {
    int sum = 0;
    for (; b; b -= (b & (-b))) sum += ft[b];
    return sum;
  }
  int rsq(int a, int b) { return rsq(b) - (a == 1 ? 0 : rsq(a - 1)); }
  void adjust(int k, int v) {
    // cout << "adjust " << k << " " << v << endl;
    for (; k < (int)ft.size(); k += (k & (-k))) {
      // cout << "k " << k << endl;
      ft[k] += v;
    }
  }
};

int ct = 0;
bool vis[200005];
ii visit(int node, int par) {
  parity[node] = par;
  vis[node] = true;
  bool isLeaf = true;
  int mn = INT_MAX, mx = INT_MIN;
  for (auto x : adjList[node])
    if (!vis[x]) {
      isLeaf = false;
      ii p = visit(x, 1 - par);
      mn = min(mn, p.first);
      mx = max(mn, p.second);
    }
  ii ret;
  if (isLeaf) {
    getDirect[node] = ct + 2;
    ret = ii(ct + 1, ct + 3);
    ct += 3;
  } else {
    ct += 3;
    getDirect[node] = mx + 2;
    ret = ii(mn, mx + 3);
  }
  intervals[node] = ret;
  return ret;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

  cin >> N >> M;
  for (int i = 1, x; i <= N; i++) cin >> arr[i];
  for (int i = 0, u, v; i < N - 1; i++) {
    cin >> u >> v;
    adjList[u].push_back(v);
    adjList[v].push_back(u);
  }

  visit(1, 0);
  // for (int i = 1; i <= N; i++) {
  //   cout << "start/end " << i << " " << intervals[i].first << " "
  //        << intervals[i].second << endl;
  // }

  FenwickTree ftOdd(10 * N + 5);
  FenwickTree ftEven(10 * N + 2);

  for (int i = 0; i < M; i++) {
    int type, x, val;
    cin >> type;

    if (type == 1) {
      cin >> x >> val;
      int s = intervals[x].first, e = intervals[x].second;
      if (parity[x]) {
        ftOdd.adjust(s, val);
        ftOdd.adjust(e, -val);
      } else {
        ftEven.adjust(s, val);
        ftEven.adjust(e, -val);
      }

    } else {
      cin >> x;
      int child = getDirect[x];
      int diff = ftEven.rsq(1, child) - ftOdd.rsq(1, child);
      if (parity[x]) diff = -diff;
      cout << arr[x] + diff << endl;
    }
  }
  return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define mkp(i,j) make_pair(i,j)
#define INF 1<<30
const int MAX=2e5+10;
typedef pair<int,int> ii;
typedef long long ll;
typedef vector<int> vi;

int n,t = 0;
vector < int > g[MAX];
ll BITO[MAX],BITE[MAX];
int d[MAX],b[MAX],e[MAX],a[MAX],L[MAX],S[MAX];

void update(ll arr[],int idx,int val){
    while(idx<=n){
        arr[idx] += ll(val);
        idx += idx & (-1*idx);
    }
}

void dfs(int u,int p,bool O){

    b[u] = ++t;
    if(O) L[t] = 1;

    update(BITE,t,a[u]);
    update(BITE,t+1,-1*a[u]);
    update(BITO,t,a[u]);
    update(BITO,t+1,-1*a[u]);

    for(auto v : g[u]){
        if(p==v) continue;
        dfs(v,u,O ^ 1);
    }
    e[u] = t;
}

void updateBIT(int idx,int val){
    int l = b[idx];
    int r = e[idx];
    if(L[l]){
        update(BITO,l,val);
        update(BITE,l,-1*val);
        update(BITO,r+1,-1*val);
        update(BITE,r+1,val);

    }else{
        update(BITE,l,val);
        update(BITO,l,-1*val);
        update(BITE,r+1,-1*val);
        update(BITO,r+1,val);
    }
}

ll getel(ll arr[],int x){
    ll el = 0ll;
    while(x>0){
        el += arr[x];
        x -= x & (-1*x);
    }
    return el;
}

void printArr(){
    for(int i = 1;i<=n;i++) cout<<BITE[i]<<" "; cout<<endl;
    for(int i = 1;i<=n;i++) cout<<BITO[i]<<" "; cout<<endl;
}
int main(){
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int m;
    cin>>n>>m;
    for(int i= 1;i<=n;i++){
        cin>>a[i];
    }
    for(int i = 1;i<n;i++){
        int u,v;
        cin>>u>>v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    dfs(1,-1,0);
    //for(int i = 1;i<=n;i++) cout<<b[i]<<" "; cout<<endl;
    //for(int i = 1;i<=n;i++) cout<<e[i]<<" "; cout<<endl;
   // for(int i = 1;i<=n;i++) {cout<<L[i]<<" ";} cout<<endl;
    //printArr();
    for(int i = 0;i<m;i++){
        int type,x; cin>>type;
        if(type==1){
            int val;
            cin>>x>>val;
            updateBIT(x,val);
           // printArr();
        }else{
            cin>>x;
            x = b[x];
            cout<<(L[x] ? getel(BITO,x) : getel(BITE,x))<<endl;
        }
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef    long long          ll;
typedef    vector<long long>    vi;
typedef    vector<vi>         vvi;
typedef    pair<long,long>      ii;
#define    sz(a)              long((a).size())
#define    pb                 push_back
#define    mp                   make_pair
#define    all(c)             (c).begin(),(c).end()
#define    tr(c,i)            for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
#define    present(c,x)       ((c).find(x) != (c).end())
#define    cpresent(c,x)      (find(all(c),x) != (c).end())
#define    input(v,n)           for(ll i = 0 ; i<n ; i++) cin>>v[i]
#define    output(v,n)          for(ll i = 0 ; i<n ; i++) cout<<v[i]<<" "

vi v;
vi g[300000];
ll vis[300000];
ll tre[1000000];
ll in[300000];
ll out[300000];
ll a[300000];
ll prt[300000];
void dfs(ll s,ll c)
{
	prt[s]=c;
	vis[s]=1;
	v.pb(s);
	in[s]=v.size()-1;
	for(ll i=0;i<g[s].size();i++)
	{
		if(vis[g[s][i]]==0)
		{
			dfs(g[s][i],c^1);
		}
	}
	out[s]=v.size()-1;
}

void update(ll nd,ll tl, ll tr,ll ind,ll val)
{
	if(!(ind>=tl && ind<=tr))return;
	if (tl==tr){
		tre[nd]+=val;
		return ;
	}

	ll mid=(tl+tr)/2;
	update(2*nd+1,tl,mid,ind,val);
	update(2*nd+2,mid+1,tr,ind,val);
	tre[nd]=tre[2*nd+1]+tre[2*nd+2];

}

ll query(ll nd,ll tl,ll tr,ll l,ll r)
{
	if(l>r)return 0;
	if(r<tl || l>tr)return 0;
	if(tl==l && tr==r)return tre[nd];
	ll mid = (tl+tr)/2;
	return query(2*nd+1,tl,mid,max(tl,l),min(mid,r)) + query(2*nd+2,mid+1,tr,max(mid+1,l),min(r,tr));
}

int main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);

  ll n,m,i;
  cin>>n>>m;

  for(i=1;i<=n;i++)
  	cin>>a[i];

  for(i=1;i<n;i++)
  {
  	ll x,y;
  	cin>>x>>y;
  	g[x].pb(y);
  	g[y].pb(x);
  }

  dfs(1,0);

  while(m--)
  {
  	ll ch;
  	cin>>ch;
  	if(ch==1)
  	{
  		ll x,val;
  		cin>>x>>val;

  		if(prt[x])val=-val;

  		update(1,0,n-1,in[x],val);
  		update(1,0,n-1,out[x]+1,-val);

  	}
  	else {
  		ll x;
  		cin>>x;
  		if(prt[x])cout<<-query(1,0,n-1,0,in[x]) + a[x]<<"\n";
  		else cout<<query(1,0,n-1,0,in[x]) + a[x]<<"\n";
  	}
  }

  return 0;
 }


/*input
5 5
1 2 1 1 2
1 2
1 3
2 4
2 5
1 2 3
1 1 2
2 1
2 2
2 4

*/
/*

**************************
*						 *
* AUTHOR :: knight_coder *
*						 *
**************************

*/
#include<bits/stdc++.h>
#define lld          long long int
#define pb          push_back
#define ppb         pop_back
#define	endl		'\n'
#define mii         map<lld,lld>
#define msi         map<string,lld>
#define mis         map<lld, string>
#define mpi         map<pair<lld ,lld >,lld >
#define pii         pair<lld,lld>
#define vi          vector<lld>
#define vpi 		vector<pii>
#define vs          vector<string>
#define all(a)      (a).begin(),(a).end()
#define F           first
#define S           second
#define sz(x)       (lld)x.size()
#define hell        1000000007
#define rrep(i,m,n)	for(lld i=m;i>=n;i--)
#define rep(i,m,n)	for(lld i=m;i<n;i++)
#define lbnd        lower_bound
#define ubnd        upper_bound
#define bs          binary_search
#define mp          make_pair
#define what_is(x)  cerr << #x << " is " << x << endl;
#define pr(x) 		cout<< x << " ";
#define pre(x)		cout<< x << endl ;
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template<typename T>
using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
//change null_type to get ordered_map
#define N  200005
lld tme[2];
lld b[N],a[N];
bool vis[N];
lld ht[N];
lld intt[N][2],outt[N][2];
lld c[N];
vi v[N];
void inii(){
	rep(i,0,N){
		a[i]=0,b[i]=0;
		vis[i]=false;
		ht[i]=0;
	}
}
void dfs(lld node,lld dep){
	vis[node]=true;
	ht[node]=dep;
	if(dep%2){
		a[tme[1]]=c[node];
	}
	else{
		b[tme[0]]=c[node];
	}
	rep(i,0,2){
		intt[node][i]=tme[i];
	}
	tme[dep%2]++;
	for(auto i:v[node]){
		if(!vis[i]){
			dfs(i,dep+1);
		}
	}
	rep(i,0,2){
		outt[node][i]=tme[i];
	}
}
lld seg[4*N][2],lazy[4*N][2];
void build(lld node,lld start,lld end,lld flag){
    if(start==end){
    	if(flag)
	        seg[node][flag]=a[start];
    	else
    		seg[node][flag]=b[start];
        return;
    }
    lld mid=(start+end)>>1;
    build(node<<1,start,mid,flag);
    build(node<<1|1,mid+1,end,flag);
    seg[node][flag]=seg[node<<1][flag]+seg[node<<1|1][flag];
}
void update(lld node,lld start,lld end,lld l,lld r,lld val,lld flag){
    if(lazy[node][flag]!=0){
        seg[node][flag]+=(end-start+1)*lazy[node][flag];
        if(start!=end){
            lazy[node<<1][flag]+=lazy[node][flag];
            lazy[node<<1|1][flag]+=lazy[node][flag];
        }
        lazy[node][flag]=0;
    }
    if(start>end || start>r || end<l) return;
    if(l<=start && end<=r){
        seg[node][flag]+=(end-start+1)*val;
        if(start!=end){
            lazy[node<<1][flag]+=val;
            lazy[node<<1|1][flag]+=val;
        }
        return;
    }
    lld mid=(start+end)>>1;
    update(node<<1,start,mid,l,r,val,flag);
    update(node<<1|1,mid+1,end,l,r,val,flag);
    seg[node][flag]=seg[node<<1][flag]+seg[node<<1|1][flag];
}
lld query(lld node,lld start,lld end,lld l,lld r,lld flag){
    if(start>end || start>r || end<l) return 0;
    if(lazy[node][flag]!=0){
        seg[node][flag]+=(end-start+1)*lazy[node][flag];
        if(start!=end){
            lazy[node<<1][flag]+=lazy[node][flag];
            lazy[node<<1|1][flag]+=lazy[node][flag];
        }
        lazy[node][flag]=0;
    }
    if(start>=l && end<=r) return seg[node][flag];
    lld mid=(start+end)>>1;
    lld q1=query(node<<1,start,mid,l,r,flag);
    lld q2=query(node<<1|1,mid+1,end,l,r,flag);
    return q1+q2;
}
void solve()
{
	inii();
	lld n,m;
	cin >> n >> m;
	rep(i,1,n+1){
		cin >> c[i];
	}
	rep(i,1,n){
		lld x,y;
		cin >> x >> y;
		v[x].pb(y),v[y].pb(x);
	}
	dfs(1,0);
	rep(i,0,2){
		build(1,0,tme[i],i);
	}
	rep(i,0,m){
		lld ty;
		cin >> ty;
		if(ty==1){
			lld x,val;
			cin >> x >> val;
			lld r=ht[x]%2;
			if(intt[x][r]<=outt[x][r]-1)
				update(1,0,tme[r],intt[x][r],outt[x][r]-1,val,r);
			if(intt[x][1^r]<=outt[x][1^r]-1)
				update(1,0,tme[r^1],intt[x][1^r],outt[x][1^r]-1,-val,1^r);
		}
		else{
			lld x;
			cin >> x;
			lld r=ht[x]%2;
			lld ans;
			if(r){
				ans=query(1,0,tme[1],intt[x][1],intt[x][1],1);
			}
			else{
				ans=query(1,0,tme[0],intt[x][0],intt[x][0],0);
			}
			cout << ans << endl;
		}
	}
}
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int tests=1;
	//cin>>tests;
	while(tests--)
	{
		solve();
	}
}


#include <iostream>
#include <bits/stdc++.h>

using namespace std;

int n,q,a[200100],Start[200100],End[200100],b[200100],Seg[2][20001000],level[200100],Lazy[2][2000100];
vector < int > v[200100];

int T = 0;

void DFS(int x, int p, int lev)
{

    level[x] = lev;
    b[++T] = x;
    Start[x] = T;

    for(int i=0; i<v[x].size(); i++)
        if(v[x][i] != p)  DFS(v[x][i], x, (lev+1)%2);

    End[x] = T;
}

void pushLazy(int id , int p){

    if(Lazy[p]){
        Lazy[id][p*2]+=Lazy[id][p];
        Lazy[id][p*2 + 1]+=Lazy[id][p];
        Seg[id][p]+=Lazy[id][p];
        Lazy[id][p] = 0;
    }
}

void Build(int id, int L =1, int R = n, int p = 1)
{

    if(L==R)
    {
        Seg[id][p] = a[b[L]];
        return;
    }

    int mid = (L+R)/2;
    Build(id, L, mid, p*2);
    Build(id, mid + 1, R, p*2 + 1);
}

void update(int id, int i, int j,int val,int L = 1, int R = n,int p=1)
{
    pushLazy(id,p);
    if(L>j || R<i)  return;
    if(L>=i && R<=j)
    {
        Lazy[id][p]+=val;
        pushLazy(id,p);
        return ;
    }

    int mid = (L + R)/2;
    update(id, i, j, val,L, mid, p*2);
    update(id, i, j, val,mid+1, R, p*2+1);
}

int query(int id, int i, int L = 1, int R = n, int p=1)
{
    pushLazy(id,p);
    if(R<i||L>i)  return 0;
    if(L==R && L==i)
        return Seg[id][p];

    int mid = (L + R) / 2;
    return query(id,i,L,mid,p*2) + query(id,i,mid+1,R,p*2+1);
}

int main()
{
    int x,y,type,val;
    scanf("%d%d",&n,&q);
    for(int i=1; i<=n; i++)  scanf("%d", &a[i]);
    for(int i=0; i<n-1; i++)
    {
        cin>>x>>y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    DFS(1,-1,0);
    Build(0);
    Build(1);
    while(q--)
    {
        scanf("%d",&type);
        if(type == 1)
        {
            scanf("%d%d",&x,&val);
            update(level[x], Start[x], End[x], val);
            update(!level[x], Start[x], End[x], -val);
        }
        else {
            scanf("%d",&x);
            printf("%d\n",query(level[x] ,Start[x]));

        }
    }
    return 0;
}


#include<bits/stdc++.h>
// __builtin_ctz : no of trailing zeros
#define int long long
#define ll long long
#define pp pair<int,int>
#define mod 1000000007
#define trace(x) cerr<<#x<<": "<<x<<" "<<endl
#define trace2(x, y) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl
#define trace3(x, y, z) cerr<<#x<<":" <<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl
#define sa(a,n) for(int i =0 ; i<n ; i++) cin>>a[i]
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define scan() int n; cin>>n ; int a[n]; for(int i = 0 ; i<n ; i++) cin>>a[i]
#define print(a,n) for(int i = 0 ; i < n ; i++) cout<<a[i]<<' '
using namespace std;
int max(int x, int y)
{
    return x>y ? x : y;
}
int min(int x, int y)
{
    return x<y ? x : y;
}
void _(int&a , int b)
{
    a=(a%mod+b%mod)%mod;
    a=(a+mod)%mod;
}
ll cl(ll a,ll b)
{
    return (a/b)+(!(!(a%b)));
}
ll t=0;
ll n,m;vector<ll> e[200010];ll a[200010];ll l[200010];ll fen[200010];ll st[200010];ll en[200010];
void dfs(ll i,ll p,ll lev)
{
	st[i]=++t;
	l[i]=lev;
	for(auto j : e[i])
	{
		if(j!=p)
		dfs(j,i,lev+1);
	}
	en[i]=t;
}
void upd(int i,int val)
{
	while(i<=n){fen[i]+=val;i+=i&-i;}
}
ll sum(ll i)
{
	int ans=0;
	while(i){ans+=fen[i];i-=i&-i;}
	return ans;
}
int32_t main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> n >> m;
    for (int i = 0; i < n; ++i)
    {
    	cin >> a[i];
    }
    for (int i = 0; i < n-1; ++i)
    {
    	ll u,v;cin >>u  >> v;u--;v--;
    	e[u].push_back(v);e[v].push_back(u);
    }
    dfs(0,-1,0);
    for (int i = 0; i < m; ++i)
    {
    	ll t;cin >> t;
    	if(t==1)
    	{
    		ll x,val;cin >> x >> val;
    		x--;
    		if(l[x]&1)val=-val;
    		upd(st[x],val);
    	    upd(en[x]+1,-val);
    	}
    	else
    	{
    		ll x;cin >> x;
    		x--;
    		if(l[x]&1)cout << a[x]-sum(st[x])<< "\n";
    		else cout << a[x]+sum(st[x]) << "\n";
    	}
    }
    }


#include<bits/stdc++.h>
// __builtin_ctz : no of trailing zeros
#define int long long
#define ll long long
#define pp pair<int,int>
#define mod 1000000007
#define trace(x) cerr<<#x<<": "<<x<<" "<<endl
#define trace2(x, y) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl
#define trace3(x, y, z) cerr<<#x<<":" <<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl
#define sa(a,n) for(int i =0 ; i<n ; i++) cin>>a[i]
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define scan() int n; cin>>n ; int a[n]; for(int i = 0 ; i<n ; i++) cin>>a[i]
#define print(a,n) for(int i = 0 ; i < n ; i++) cout<<a[i]<<' '
using namespace std;
int max(int x, int y)
{
    return x>y ? x : y;
}
int min(int x, int y)
{
    return x<y ? x : y;
}
void _(int&a , int b)
{
    a=(a%mod+b%mod)%mod;
    a=(a+mod)%mod;
}
ll cl(ll a,ll b)
{
    return (a/b)+(!(!(a%b)));
}
ll t=1;
ll n,m;vector<ll> e[200010];ll a[200010];ll l[200010];ll fen[200010];ll st[200010];ll en[200010];
void dfs(ll i,ll p,ll lev)
{
	st[i]=++t;
	l[i]=lev;
	for(auto j : e[i])
	{
		if(j!=p)
		dfs(j,i,lev+1);
	}
	en[i]=t;
}
void upd(int i,int val)
{
	while(i<=n){fen[i]+=val;i+=i&-i;}
}
ll sum(ll i)
{
	int ans=0;
	while(i){ans+=fen[i];i-=i&-i;}
	return ans;
}
int32_t main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> n >> m;
    for (int i = 0; i < n; ++i)
    {
    	cin >> a[i];
    }
    for (int i = 0; i < n-1; ++i)
    {
    	ll u,v;cin >>u  >> v;u--;v--;
    	e[u].push_back(v);e[v].push_back(u);
    }
    dfs(0,-1,0);
    for (int i = 0; i < m; ++i)
    {
    	ll t;cin >> t;
    	if(t==1)
    	{
    		ll x,val;cin >> x >> val;
    		x--;
    		if(l[x]&1)val=-val;
    		upd(st[x],val);
    	    upd(en[x]+1,-val);
    	}
    	else
    	{
    		ll x;cin >> x;
    		x--;
    		if(l[x]&1)cout << a[x]-sum(st[x])<< "\n";
    		else cout << a[x]+sum(st[x]) << "\n";
    	}
    }
    }


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#pragma GCC optimize("O3")
//#pragma GCC optimize ("Ofast,no-stack-protector,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
//#pragma GCC target("avx,tune=native")

using namespace std;
using namespace __gnu_pbds;

//const int MAX_MEM = 1e8; int mpos = 0; char mem[MAX_MEM]; inline void * operator new ( size_t n ) { char *res = mem + mpos; mpos += n; assert(mpos <= MAX_MEM); return (void *)res; } inline void operator delete ( void * ) { }

typedef long double ld;
typedef long long ll;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

#define _ inline
#define f first
#define sec second
#define pb push_back
#define ins insert
#define ers erase
#define mk make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rsz resize
#define int ll
#define forn(i, n) for (register int i(1); i <= n; i++)
#define fore(i, n) for (register int i(0); i < n; i++)

#define right rightt
#define left leftt
#define prev prevv
#define next nextt

mt19937 Random(time(0));

const int INF = 1e9 + 10;
const int MOD = 1e9 + 7;
const int P = 239017;
const long long BINF = 1e18 + 10;

const int N = 2e5 + 10;
int t1[8 * N], t2[8 * N], f1[8 * N], f2[8 * N], h[N], val[N];
vector<int> arr;
vector<vector<int> > g;

void dfs(int v, int p = 0, int cur_h = 0) {
    h[v] = cur_h;
    arr.pb(v);
    for (auto u : g[v]) {
        if (u != p) {
            dfs(u, v, cur_h + 1);
        }
    }
    arr.pb(v);
}

void build1(int v, int l, int r) {
    if (l == r) {
        t1[v] = val[arr[l - 1]];
        return;
    }
    int mid = (l + r) >> 1;
    build1(2 * v, l, mid);
    build1(2 * v + 1, mid + 1, r);
}

void build2(int v, int l, int r) {
    if (l == r) {
        t2[v] = val[arr[l - 1]];
        return;
    }
    int mid = (l + r) / 2;
    build2(2 * v, l, mid);
    build2(2 * v + 1, mid + 1, r);
}

void push1(int v) {
    t1[2 * v] += f1[v];
    f1[2 * v] += f1[v];
    t1[2 * v + 1] += f1[v];
    f1[2 * v + 1] += f1[v];
    f1[v] = 0;
}

void push2(int v) {
    t2[2 * v] += f2[v];
    f2[2 * v] += f2[v];
    t2[2 * v + 1] += f2[v];
    f2[2 * v + 1] += f2[v];
    f2[v] = 0;
}

void upd1(int v, int l, int r, int a, int b, int delta) {
    if (l > b || r < a) {
        return;
    }
    if (l >= a && r <= b) {
        f1[v] += delta;
        t1[v] += delta;
        return;
    }
    push1(v);
    int mid = (l + r) >> 1;
    upd1(2 * v, l, mid, a, b, delta);
    upd1(2 * v + 1, mid + 1, r, a, b, delta);
}

void upd2(int v, int l, int r, int a, int b, int delta) {
    if (l > b || r < a) {
        return;
    }
    if (l >= a && r <= b) {
        f2[v] += delta;
        t2[v] += delta;
        return;
    }
    push2(v);
    int mid = (l + r) >> 1;
    upd2(2 * v, l, mid, a, b, delta);
    upd2(2 * v + 1, mid + 1, r, a, b, delta);
}

int get1(int v, int l, int r, int need) {
    if (l == r) {
        return t1[v];
    }
    push1(v);
    int mid = (l + r) >> 1;
    if (need <= mid) {
        return get1(2 * v, l, mid, need);
    }
    else {
        return get1(2 * v + 1, mid + 1, r, need);
    }
}

int get2(int v, int l, int r, int need) {
    if (l == r) {
        return t2[v];
    }
    push2(v);
    int mid = (l + r) >> 1;
    if (need <= mid) {
        return get2(2 * v, l, mid, need);
    }
    else {
        return get2(2 * v + 1, mid + 1, r, need);
    }
}

int f[N], en[N];

_ void source() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> val[i];
    }
    g.rsz(n + 1);
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }
    dfs(1);
    int sz = arr.size();
    for (int i = 0; i < sz; i++) {
        if (!f[arr[i]]) {
            f[arr[i]] = i + 1;
        }
        en[arr[i]] = i + 1;
    }
    build1(1, 1, sz);
    build2(1, 1, sz);
    for (int i = 1; i <= m; i++) {
        int type, v;
        cin >> type >> v;
        if (type == 1) {
            int delta;
            cin >> delta;
            if (h[v] & 1) {
                upd1(1, 1, sz, f[v], en[v], delta);
                upd2(1, 1, sz, f[v], en[v], -delta);
            }
            else {
                upd1(1, 1, sz, f[v], en[v], -delta);
                upd2(1, 1, sz, f[v], en[v], delta);
            }
        }
        else {
            cout << (h[v] & 1 ? get1(1, 1, sz, f[v]) : get2(1, 1, sz, f[v])) << '\n';
        }
    }

}

signed main() {
#ifdef EXTRATERRESTRIAL_
    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
#else
    //freopen(TASK".in", "r", stdin);
    //freopen(TASK".out", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    source();
    return 0;
}


#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define endl '\n'
typedef long long ll;
typedef pair<int, int> ii;
//	Table is the complete reverse of dp
//	Always think of the pattern (LCM, GCD)
//	Be careful of unsigned
//	Think of a solution that gets TLE and optimize it
//	Use binary search
//	Solve on paper first
struct segtree{
	int n;
	struct node{
		int val, oddLazy, evenLazy;
		bool odd;
		node *right, *left;
		node(): val(0), oddLazy(0), evenLazy(0), odd(0), right(nullptr), left(nullptr){}
	} *root;
	segtree(int m): n(m), root(nullptr){}
	void push(node *p, int l, int r)
	{
		if(l != r)
		{
			p->left->oddLazy += p->oddLazy;
			p->left->evenLazy += p->evenLazy;
			p->right->oddLazy += p->oddLazy;
			p->right->evenLazy += p->evenLazy;
		}
		else
			p->val += (p->odd? -1: 1) * (p->evenLazy - p->oddLazy);
		p->oddLazy = p->evenLazy = 0;
	}
	void build(int *x, bool *dep, const vector<int>& y)
	{
		root = __build(x, dep, y, root, 0, n - 1);
	}
	node* __build(int *x, bool *dep, const vector<int>& y, node* p, int l, int r)
	{
		p = new node;
		if(l == r)
		{
			p->val = x[y[l]];
			p->odd = dep[y[l]];
			return p;
		}
		p->left = __build(x, dep, y, p->left, l, l + r >> 1);
		p->right = __build(x, dep, y, p->right, (l + r >> 1) + 1, r);
		return p;
	}
	void update(const int& st, const int& ed, const int& val, const bool odd)
	{
		__update(st, ed, val, odd, root, 0, n - 1);
	}
	void __update(const int& st, const int& ed, const int& val, const bool& odd, node *p, int l, int r)
	{
		push(p, l, r);
		if(l > ed || r < st)
			return;
		if(l >= st && r <= ed)
		{
			if(odd)
				p->oddLazy += val;
			else
				p->evenLazy += val;
			push(p, l, r);
			return;
		}
		__update(st, ed, val, odd, p->left, l, l + r >> 1);
		__update(st, ed, val, odd, p->right, (l + r >> 1) + 1, r);
	}
	int get(const int& idx)
	{
		return __get(idx, root, 0, n - 1);
	}
	int __get(const int& idx, node* p, int l, int r)
	{
		push(p, l, r);
		if(l > idx || r < idx)
			return 0;
		if(l == idx && r == idx)
			return p->val;
		return __get(idx, p->left, l, l + r >> 1) + __get(idx, p->right, (l + r >> 1) + 1, r);
	}
};
int n, m, *p, *st, *ed;
bool *dep;
vector<int> *e, y;
void dfs(int i = 0, int par = -1)
{
	st[i] = y.size();
	y.push_back(i);
	for(int &j: e[i])
		if(j != par)
		{
			dep[j] = !dep[i];
			dfs(j, i);
		}
	ed[i] = y.size() - 1;
}
int main()
{
    cin.tie(nullptr); ios_base::sync_with_stdio(0);
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    clock_t START_TIME = clock();
#endif
    scanf("%d%d", &n, &m);
    segtree x(n);
    p = new int[n];
    for(int i = 0; i < n; i++)
    	scanf("%d", p + i);
    e = new vector<int>[n];
    for(int i = 1, u, v; i < n; i++)
    {
    	scanf("%d%d", &u, &v);
    	u--;
    	v--;
    	e[u].push_back(v);
    	e[v].push_back(u);
    }
    st = new int[n];
    ed = new int[n];
    dep = new bool[n];
    dep[0] = 0;
    dfs();
    x.build(p, dep, y);
    //printf("// %d\n", x.get(st[3]));
    while(m--)
    {
    	int t, z;
    	scanf("%d%d", &t, &z);
    	z--;
    	if(t == 1)
    	{
    		int v;
    		scanf("%d", &v);
    		x.update(st[z], ed[z], v, dep[z]);
    	    //printf("// %d\n", x.get(st[3]));
    	}
    	else
    		printf("%d\n", x.get(st[z]));
    }
#ifndef ONLINE_JUDGE
    printf("\n// Time taken = %.3f ms", (clock() - START_TIME) * 1e3 / CLOCKS_PER_SEC);
#endif
}


#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#include <bits/stdc++.h>
using namespace std;

#ifdef LOCAL
#include "debug.h"
#else
#define debug(...)
#endif

#define df(b, e) ((b) > (e))
#define fore(i, b, e) for (auto i = (b) - df(b, e); i != e - df(b, e); i += 1 - 2 * df(b, e))
#define sz(x) int(x.size())
#define all(x) begin(x), end(x)
#define f first
#define s second
#define pb push_back

typedef long long lli;
typedef long double ld;
typedef pair<int, int> ii;
typedef vector<int> vi;

const int N = 200005;

vector<int> graph[N];
int tin[N], tout[N], timer = 0;
int dep[N], a[N];
int n, m;

template <class T>
struct Fenwick {
  #define lsb(x) (x & -x)
  vector<T> fenw;

  Fenwick(int n = 0) : fenw(n + 1, {}) {}

  void update(int l, int r, T v) {
    for (; l < sz(fenw); l += lsb(l))
      fenw[l] += v;
    for (++r; r < sz(fenw); r += lsb(r))
      fenw[r] -= v;
  }

  T query(int i) {
    T v = {};
    for (; i > 0; i -= lsb(i))
      v += fenw[i];
    return v;
  }
};

void dfs(int u, int p = 0) {
  tin[u] = ++timer;
  for (int v : graph[u])
    if (!tin[v]) {
      dep[v] = dep[u] + 1;
      dfs(v, u);
    }
  tout[u] = timer;
}

int main() {
  cin.tie(0)->sync_with_stdio(0), cout.tie(0);
  cin >> n >> m;
  Fenwick<int> tree(n);
  fore (u, 1, n + 1)
    cin >> a[u];
  fore (i, 0, n - 1) {
    int u, v;
    cin >> u >> v;
    graph[u].pb(v);
    graph[v].pb(u);
  }
  dfs(1);
  for (int op, u, val; m--; ) {
    cin >> op >> u;
    if (op == 1) {
      cin >> val;
      if (dep[u] % 2)
        val = -val;
      tree.update(tin[u], tout[u], val);
    } else {
      val = tree.query(tin[u]);
      if (dep[u] % 2)
        val = -val;
      cout << a[u] + val << '\n';
    }
  }
  return 0;
}


// Sakhiya07 - Yagnik Sakhiya

#include <bits/stdc++.h>
using namespace std;

#define ll long long int
#define ld long double
#define ff first
#define ss second
#define pb push_back
#define all(x) x.begin(),x.end()
#define pll pair<ll,ll>

#define mp make_pair
#define bp __builtin_popcountll
#define MOD  1000000007
const int N = 200005;
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);srand(time(NULL));
pair<ll,ll> p[N];
vector<ll> v[N];
ll crt = 0,level[N];
struct ft {
    vector<ll> bit;
    ll n;
    ft() {
        n = 2*N+5;
        bit.assign(n,0);
    }
    ll sum(ll r) {
        ll ret = 0;
        for(; r >= 0; r = (r&(r+1))-1)
            ret += bit[r];
        return ret;
    }
    void add(ll idx, ll d) {
        for(; idx < n; idx = idx | (idx+1))
            bit[idx] += d;
    }
    ll sum(ll l, ll r) {
        return sum(r) - sum(l-1);
    }
};
void dfs(ll id,ll p1,ll l)
{
     level[id] = l;
     p[id].ff = crt++;
     for(auto X:v[id])
     {
          if(X!=p1)
          {
               dfs(X,id,l+1);
          }
     }
     p[id].ss = crt++;
}
void solve()
{
     ll n,q;
     cin >> n >> q;
     ft ft1[2];
     ll a[n+1];
     for(ll i=1;i<=n;i++)   cin >> a[i];
     for(ll i=0;i<n-1;i++)
     {
          ll x,y;
          cin >> x >> y;
          v[x].pb(y);
          v[y].pb(x);
     }
     dfs(1,0,0);
     while(q--)
     {
          ll type;
          cin >> type;
          if(type==1)
          {
               ll node,value;
               cin >> node >> value;
               ll l = level[node]%2;
               ft1[l].add(p[node].ff,value);
               ft1[l].add(p[node].ss+1,-value);
               l ^= 1;
               ft1[l].add(p[node].ff,-value);
               ft1[l].add(p[node].ss+1,value);
          }
          else
          {
               ll node;
               cin >> node;
               ll l = level[node]%2;
               ll ans = a[node] + ft1[l].sum(p[node].ff);
               cout<<ans<<"\n";
          }
     }
}

int main()
{
     FAST;
     ll t = 1;
  //   cin >> t;
     while(t--)
     {
          solve();
     }
}


// Sakhiya07 - Yagnik Sakhiya

#include <bits/stdc++.h>
using namespace std;

#define ll long long int
#define ld long double
#define ff first
#define ss second
#define pb push_back
#define all(x) x.begin(),x.end()
#define pll pair<ll,ll>

#define mp make_pair
#define bp __builtin_popcountll
#define MOD  1000000007
const int N = 200005;
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);srand(time(NULL));
pair<ll,ll> p[N];
vector<ll> v[N];
ll crt = 0,level[N];
struct ft {
    vector<ll> bit;
    ll n;
    ft(ll n1) {
        n = n1;
        bit.assign(n,0);
    }
    ll sum(ll r) {
        ll ret = 0;
        for(; r >= 0; r = (r&(r+1))-1)
            ret += bit[r];
        return ret;
    }
    void add(ll idx, ll d) {
        for(; idx < n; idx = idx | (idx+1))
            bit[idx] += d;
    }
    ll sum(ll l, ll r) {
        return sum(r) - sum(l-1);
    }
};
void dfs(ll id,ll p1,ll l)
{
     level[id] = l;
     p[id].ff = crt++;
     for(auto X:v[id])
     {
          if(X!=p1)
          {
               dfs(X,id,l+1);
          }
     }
     p[id].ss = crt++;
}
void solve()
{
     ll n,q;
     cin >> n >> q;
     ft ft[2](2*n+5);
     ll a[n+1];
     for(ll i=1;i<=n;i++)   cin >> a[i];
     for(ll i=0;i<n-1;i++)
     {
          ll x,y;
          cin >> x >> y;
          v[x].pb(y);
          v[y].pb(x);
     }
     dfs(1,0,0);
     while(q--)
     {
          ll type;
          cin >> type;
          if(type==1)
          {
               ll node,value;
               cin >> node >> value;
               ll l = level[node]%2;
               ft[l].add(p[node].ff,value);
               ft[l].add(p[node].ss+1,-value);
               l ^= 1;
               ft[l].add(p[node].ff,-value);
               ft[l].add(p[node].ss+1,value);
          }
          else
          {
               ll node;
               cin >> node;
               ll l = level[node]%2;
               ll ans = a[node] + ft[l].sum(p[node].ff);
               cout<<ans<<"\n";
          }
     }
}

int main()
{
     FAST;
     ll t = 1;
  //   cin >> t;
     while(t--)
     {
          solve();
     }
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define mod 1000000007
#define MAX 1000000000000000
#define all(v) v.begin(),v.end()
#define rep(i,a,b) for(i=(ll)a;i<(ll)b;i++)
#define revrep(i,a,b) for(i=(ll)a;i>=(ll)b;i--)
#define ii pair<ll,pair<ll,ll> >
#define MP make_pair
#define pb push_back
#define f first
#define se second
#define ll long long int
#define vi vector<ll>
ll modexp(ll a,ll b){ ll res = 1; while(b > 0){  if(b & 1) res = (res * a)%mod;  a = (a * a)%mod;  b/=2;  }  return res; }
#define rs resize
typedef tree< ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update > OST;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cout << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
    }
#else
#define trace(...)
#endif

const ll N = 200009;
ll n,i,a,b,m,T,q,v;
vector<vi> adj;
ll val[N],L[N],ver[N],st[N],ft[N];
ll t[2][N << 2],c[2][N << 2],lzy[2][N << 2];
void dfs(ll v,ll par,ll l)
{
    L[v] = l;
    ver[T] = v;
    st[v] = T++;
    for(auto &it: adj[v]) if(it != par)
        dfs(it,v,l + 1);
    ft[v] = T;
}
void build(ll i,ll l,ll r)
{
    if(l == r){
        t[L[ver[l]] & 1][i] = val[ver[l]];
        c[L[ver[l]] & 1][i] = 1;
        return;
    }
    ll m = (l + r) / 2;
    build(2*i + 1,l,m);
    build(2*i + 2,m + 1,r);
    for(ll j = 0;j < 2;j++){
        t[j][i] = t[j][2*i + 1] + t[j][2*i + 2];
        c[j][i] = c[j][2*i + 1] + c[j][2*i + 2];
    }
}
void up(ll i,ll p,ll v,ll s,ll e,ll l,ll r)
{
    if(lzy[p][i] != 0){
        t[p][i] += c[p][i] * lzy[p][i];
        if(s != e){
            lzy[p][2*i + 1] += lzy[p][i];
            lzy[p][2*i + 2] += lzy[p][i];
        }
        lzy[p][i] = 0;
    }
    if(e < l or s > r) return;
    if(l <= s and e <= r){
        t[p][i] += c[p][i] * v;
        if(s != e){
            lzy[p][2*i + 1] += v;
            lzy[p][2*i + 2] += v;
        }
        return;
    }
    ll m = (s + e) / 2;
    up(2*i + 1,p,v,s,m,l,r);
    up(2*i + 2,p,v,m + 1,e,l,r);
    for(ll j = 0;j < 2;j++)
        t[j][i] = t[j][2*i + 1] + t[j][2*i + 2];
}
ll query(ll i,ll p,ll s,ll e,ll l,ll r)
{
    if(lzy[p][i] != 0){
        t[p][i] += c[p][i] * lzy[p][i];
        if(s != e){
            lzy[p][2*i + 1] += lzy[p][i];
            lzy[p][2*i + 2] += lzy[p][i];
        }
        lzy[p][i] = 0;
    }
    if(e < l or s > r) return  0;
    if(l <= s and e <= r)
        return t[p][i];
    ll m = (s + e) / 2;
    return query(2*i + 1,p,s,m,l,r) + query(2*i + 2,p,m + 1,e,l,r);
}
int main()
{
    std::ios_base::sync_with_stdio(false); cin.tie(NULL);
    cin>>n>>m;
    rep(i,0,n) cin>>val[i];
    adj.rs(n);
    rep(i,1,n){
        cin>>a>>b;
        a -= 1; b -= 1;
        adj[a].pb(b);
        adj[b].pb(a);
    }
    dfs(0,-1,1);
    build(0,0,n - 1);
    while(m--){
        cin>>q>>v;
        v -= 1;
        if(q == 1){
            cin>>a;
            up(0,L[v] & 1,a,0,n - 1,st[v],ft[v] - 1);
            up(0,1 - (L[v] & 1),-a,0,n - 1,st[v],ft[v] - 1);
        }
        else
            cout<<query(0,L[v] & 1,0,n - 1,st[v],st[v])<<endl;
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

const int maxn = 2e5+10;

vector<int> grafo[maxn];

int n, m, a[maxn], in[maxn], out[maxn], t = 1, bit[maxn];

bool level[maxn];

void update(int x, int v){
    while(x <= t){
        bit[x] += v;
        x += (x&-x);
    }
}

int query(int x){
    int s = 0;
    while(x){
        s += bit[x];
        x -= (x&-x);
    }
    return s;
}

void dfs(int u, int p=0){
    in[u] = ++t;
    for(auto v : grafo[u]){
        if(v == p) continue;
        level[v] = 1^level[u];
        dfs(v, u);
    }
    out[u] = t;
}

int main(){
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cin >> n >> m;
    for(int i=1; i<=n; i++) cin >> a[i];
    for(int i=1; i<n; i++){
        int u, v;
        cin >> u >> v;
        grafo[u].push_back(v);
        grafo[v].push_back(u);
    }
    dfs(1);
    while(m--){
        int t, x, val;
        cin >> t >> x;
        if(t == 1){
            cin >> val;
            if(level[x]) val *= -1;
            update(in[x], val);
            update(out[x], -val);
        }
        if(t == 2){
            int ans = query(in[x]);
            if(level[x]) ans *= -1;
            cout << ans + a[x] << "\n";
        }
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

const int maxn = 2e5+10;

vector<int> grafo[maxn];

int n, m, a[maxn], in[maxn], out[maxn], t, bit[maxn];

bool level[maxn];

void update(int x, int v){
    while(x <= t){
        bit[x] += v;
        x += (x&-x);
    }
}

int query(int x){
    int s = 0;
    while(x){
        s += bit[x];
        x -= (x&-x);
    }
    return s;
}

void dfs(int u, int p=0){
    in[u] = ++t;
    for(auto v : grafo[u]){
        if(v == p) continue;
        level[v] = 1^level[u];
        dfs(v, u);
    }
    out[u] = t;
}

int main(){
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cin >> n >> m;
    for(int i=1; i<=n; i++) cin >> a[i];
    for(int i=1; i<n; i++){
        int u, v;
        cin >> u >> v;
        grafo[u].push_back(v);
        grafo[v].push_back(u);
    }
    dfs(1);
    while(m--){
        int t, x, val;
        cin >> t >> x;
        if(t == 1){
            cin >> val;
            if(level[x]) val *= -1;
            update(in[x], val);
            update(out[x]+1, -val);
        }
        if(t == 2){
            int ans = query(in[x]);
            if(level[x]) ans *= -1;
            cout << ans + a[x] << "\n";
        }
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

const int maxn = 2e5+10;

vector<int> grafo[maxn];

int n, m, a[maxn], in[maxn], out[maxn], t = 1, bit[maxn];

bool level[maxn];

void update(int x, int v){
    while(x <= t){
        bit[x] += v;
        x += (x&-x);
    }
}

int query(int x){
    int s = 0;
    while(x){
        s += bit[x];
        x -= (x&-x);
    }
    return s;
}

void dfs(int u, int p=0){
    in[u] = ++t;
    for(auto v : grafo[u]){
        if(v == p) continue;
        level[v] = 1^level[u];
        dfs(v, u);
    }
    out[u] = ++t;
}

int main(){
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cin >> n >> m;
    for(int i=1; i<=n; i++) cin >> a[i];
    for(int i=1; i<n; i++){
        int u, v;
        cin >> u >> v;
        grafo[u].push_back(v);
        grafo[v].push_back(u);
    }
    dfs(1);
    while(m--){
        int t, x, val;
        cin >> t >> x;
        if(t == 1){
            cin >> val;
            if(level[x]) val *= -1;
            update(in[x], val);
            update(out[x]+1, -val);
        }
        if(t == 2){
            int ans = query(in[x]);
            if(level[x]) ans *= -1;
            cout << ans + a[x] << "\n";
        }
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <functional>

using namespace std;

template<class T> class SegTree {
public:
    SegTree(int rmin, int rmax, function<T(T,T)> f, T e) :
        rmin(rmin), rmax(rmax), size(rmax-rmin), combine(f), neutral(e), tree(4*size, e) {};
    T getIn(int l, int r) {
        return getInP(max(0,l-rmin), min(size,r-rmin), 1, 0, size);
    }
    void setAt(int p, T v) {
        if (p < rmin || p > rmax) return;
        setAtP(p-rmin, v, 1, 0, size);
    }
    void updAt(int p, function<T(T)> f) {
        updAtP(p-rmin, f, 1, 0, size);
    }
private:
    int size, rmin, rmax;
    T neutral;
    function<T(T,T)> combine;
    vector<T> tree;
    T getInP(int l, int r, int i, int li, int ri) {
        if (l == li && r == ri) return tree[i];
        int mid = (li + ri) / 2;
        if (r <= mid) return getInP(l, r, 2*i, li, mid);
        if (l > mid) return getInP(l, r, 2*i+1, mid+1, ri);
        return combine(getInP(l, mid, 2*i, li, mid), getInP(mid+1, r, 2*i+1, mid+1, ri));
    }
    T setAtP(int p, T v, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = v;
        int mid = (li + ri) / 2;
        return tree[i] = combine(setAtP(p, v, 2*i, li, mid), setAtP(p, v, 2*i+1, mid+1, ri));
    }
    T updAtP(int p, function<T(T)> f, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = f(tree[i]);
        int mid = (li + ri) / 2;
        return tree[i] = combine(updAtP(p, f, 2*i, li, mid), updAtP(p, f, 2*i+1, mid+1, ri));
    }
};

int dfs(const vector<vector<int>> & tree, int v, int l, int t, vector<int> & levels, vector<int> &tin, vector<int> &tout) {
    levels[v] = l;
    tin[v] = t++;
    for (auto next : tree[v]) {
        t = dfs(tree, next, l+1, t, levels, tin, tout);
    }
    tout[v] = t;
    return t;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> vals(n);
    for (int i = 0; i < n; i++) cin >> vals[i];
    vector<vector<int>> tree(n);
    for (int i = 0; i < n-1; i++) {
        int f, t;
        cin >> f >> t;
        tree[f-1].push_back(t-1);
    }
    SegTree<int> additions(0,n, [](int x, int y) { return x+y;}, 0);

    vector<int> levels(n);
    vector<int> tin(n);
    vector<int> tout(n);

    dfs(tree, 0, 0, 0, levels, tin, tout);

    for (int i = 0; i < m; i++) {
        int typ, x;
        cin >> typ >> x;
        if (typ == 1) {
            int val;
            cin >> val;
            if (levels[x-1] & 1) val = -val;
            additions.updAt(tin[x-1], [val](int v) {return v+val;});
            additions.updAt(tout[x-1], [val](int v) {return v-val;});
        } else {
            int a = additions.getIn(0,tin[x-1]);
            if (levels[x-1] & 1) a = -a;
            cout << vals[x-1] + a << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <functional>

using namespace std;

template<class T> class SegTree {
public:
    SegTree(int rmin, int rmax, function<T(T,T)> f, T e) :
        rmin(rmin), rmax(rmax), size(rmax-rmin), combine(f), neutral(e), tree(4*size, e) {};
    T getIn(int l, int r) {
        return getInP(max(0,l-rmin), min(size,r-rmin), 1, 0, size);
    }
    void setAt(int p, T v) {
        if (p < rmin || p > rmax) return;
        setAtP(p-rmin, v, 1, 0, size);
    }
    void updAt(int p, function<T(T)> f) {
        updAtP(p-rmin, f, 1, 0, size);
    }
private:
    int size, rmin, rmax;
    T neutral;
    function<T(T,T)> combine;
    vector<T> tree;
    T getInP(int l, int r, int i, int li, int ri) {
        if (l == li && r == ri) return tree[i];
        int mid = (li + ri) / 2;
        if (r <= mid) return getInP(l, r, 2*i, li, mid);
        if (l > mid) return getInP(l, r, 2*i+1, mid+1, ri);
        return combine(getInP(l, mid, 2*i, li, mid), getInP(mid+1, r, 2*i+1, mid+1, ri));
    }
    T setAtP(int p, T v, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = v;
        int mid = (li + ri) / 2;
        return tree[i] = combine(setAtP(p, v, 2*i, li, mid), setAtP(p, v, 2*i+1, mid+1, ri));
    }
    T updAtP(int p, function<T(T)> f, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = f(tree[i]);
        int mid = (li + ri) / 2;
        return tree[i] = combine(updAtP(p, f, 2*i, li, mid), updAtP(p, f, 2*i+1, mid+1, ri));
    }
};

template <class T> class BIT {
public:
    BIT(int rmin, int rmax, function<T(T,T)> f, function<T(T,T)> g, T e) :
        rmin(rmin), rmax(rmax), combine(f), reverse(g), size(rmax-rmin), tree(size, e), neutral(e) {};
    T getUpTo(int x) { return getUpToP(min(size, x - rmin + 1), neutral); }
    T getIn(int l, int r) {
        return reverse(getUpTo(r), getUpTo(l));
    }
    void setAt(int p, T v) {
        T oldV = getIn(p, p);
        T d = reverse(v, oldV);
        updAtWithDiff(p, d);
    }
    void updAt(int p, function<T(T)> f) {
        T oldV = getIn(p, p);
        T d = reverse(f(oldV), oldV);
        updAtWithDiff(p, d);
    }
    void updAtWithDiff(int p, T d) {
        if (p == 0) return;
        tree[p] = combine(tree[p], d);
        int minBit = p & -p;
        updAtWithDiff(p ^ minBit, d);
    }
private:
    int size, rmin, rmax;
    function<T(T,T)> combine;
    function<T(T,T)> reverse;
    T neutral;
    vector<T> tree;
    T getUpToP(int i, T soFar) {
        if (i == 0) return soFar;
        int minBit = i & -i;
        return getUpToP(i ^ minBit, reverse(tree[minBit], soFar));
    }
};

int dfs(const vector<vector<int>> & tree, int v, int l, int t, vector<int> & levels, vector<int> &tin, vector<int> &tout) {
    levels[v] = l;
    tin[v] = t++;
    for (auto next : tree[v]) {
        t = dfs(tree, next, l+1, t, levels, tin, tout);
    }
    tout[v] = t;
    return t;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> vals(n);
    for (int i = 0; i < n; i++) cin >> vals[i];
    vector<vector<int>> tree(n);
    for (int i = 0; i < n-1; i++) {
        int f, t;
        cin >> f >> t;
        tree[f-1].push_back(t-1);
    }
//    SegTree<int> additions(0,n, [](int x, int y) { return x+y;}, 0);

    BIT<int> additions(0,n, [](int x, int y) {return x+y;}, [](int x, int y) {return x-y;}, 0);
    vector<int> levels(n);
    vector<int> tin(n);
    vector<int> tout(n);

    dfs(tree, 0, 0, 0, levels, tin, tout);

    for (int i = 0; i < m; i++) {
        int typ, x;
        cin >> typ >> x;
        if (typ == 1) {
            int val;
            cin >> val;
            if (levels[x-1] & 1) val = -val;
            additions.updAtWithDiff(tin[x-1], val);
            additions.updAtWithDiff(tout[x-1], -val);
        } else {
            int a = additions.getUpTo(tin[x-1]);
            if (levels[x-1] & 1) a = -a;
            cout << vals[x-1] + a << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <functional>

using namespace std;

template<class T> class SegTree {
public:
    SegTree(int rmin, int rmax, function<T(T,T)> f, T e) :
        rmin(rmin), rmax(rmax), size(rmax-rmin), combine(f), neutral(e), tree(4*size, e) {};
    T getIn(int l, int r) {
        return getInP(max(0,l-rmin), min(size,r-rmin), 1, 0, size);
    }
    void setAt(int p, T v) {
        if (p < rmin || p > rmax) return;
        setAtP(p-rmin, v, 1, 0, size);
    }
    void updAt(int p, function<T(T)> f) {
        updAtP(p-rmin, f, 1, 0, size);
    }
private:
    int size, rmin, rmax;
    T neutral;
    function<T(T,T)> combine;
    vector<T> tree;
    T getInP(int l, int r, int i, int li, int ri) {
        if (l == li && r == ri) return tree[i];
        int mid = (li + ri) / 2;
        if (r <= mid) return getInP(l, r, 2*i, li, mid);
        if (l > mid) return getInP(l, r, 2*i+1, mid+1, ri);
        return combine(getInP(l, mid, 2*i, li, mid), getInP(mid+1, r, 2*i+1, mid+1, ri));
    }
    T setAtP(int p, T v, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = v;
        int mid = (li + ri) / 2;
        return tree[i] = combine(setAtP(p, v, 2*i, li, mid), setAtP(p, v, 2*i+1, mid+1, ri));
    }
    T updAtP(int p, function<T(T)> f, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = f(tree[i]);
        int mid = (li + ri) / 2;
        return tree[i] = combine(updAtP(p, f, 2*i, li, mid), updAtP(p, f, 2*i+1, mid+1, ri));
    }
};

int dfs(const vector<vector<int>> & tree, int v, int l, int t, vector<int> & levels, vector<int> &tin, vector<int> &tout) {
    levels[v] = l;
    tin[v] = t++;
    for (auto next : tree[v]) {
        t = dfs(tree, next, l+1, t, levels, tin, tout);
    }
    tout[v] = t;
    return t;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> vals(n);
    for (int i = 0; i < n; i++) cin >> vals[i];
    vector<vector<int>> tree(n);
    for (int i = 0; i < n-1; i++) {
        int f, t;
        cin >> f >> t;
        tree[f-1].push_back(t-1);
    }
    SegTree<int> additions(0,n-1, [](int x, int y) { return x+y;}, 0);

    vector<int> levels(n);
    vector<int> tin(n);
    vector<int> tout(n);

    dfs(tree, 0, 0, 0, levels, tin, tout);

    for (int i = 0; i < m; i++) {
        int typ, x;
        cin >> typ >> x;
        if (typ == 1) {
            int val;
            cin >> val;
            if (levels[x-1] & 1) val = -val;
            additions.updAt(tin[x-1], [val](int v) {return v+val;});
            additions.updAt(tout[x-1], [val](int v) {return v-val;});
        } else {
            int a = additions.getIn(0,tin[x-1]);
            if (levels[x-1] & 1) a = -a;
            cout << vals[x-1] + a << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <functional>

using namespace std;

template<class T> class SegTree {
public:
    SegTree(int rmin, int rmax, function<T(T,T)> f, T e) :
        rmin(rmin), rmax(rmax), size(rmax-rmin), combine(f), neutral(e), tree(4*size, e) {};
    T getIn(int l, int r) {
        return getInP(l-rmin, r-rmin, 1, 0, size);
    }
    void setAt(int p, T v) {
        setAtP(p-rmin, v, 1, 0, size);
    }
    void updAt(int p, function<T(T)> f) {
        updAtP(p-rmin, f, 1, 0, size);
    }
private:
    int size, rmin, rmax;
    T neutral;
    function<T(T,T)> combine;
    vector<T> tree;
    T getInP(int l, int r, int i, int li, int ri) {
        if (l == li && r == li) return tree[i];
        int mid = (li + ri) / 2;
        if (r <= mid) return getInP(l, r, 2*i, li, mid);
        if (l > mid) return getInP(l, r, 2*i+1, mid+1, ri);
        return combine(getInP(l, mid, 2*i, li, mid), getInP(mid+1, r, 2*i+1, mid+1, ri));
    }
    T setAtP(int p, T v, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = v;
        int mid = (li + ri) / 2;
        return tree[i] = combine(setAtP(p, v, 2*i, li, mid), setAtP(p, v, 2*i+1, mid+1, ri));
    }
    T updAtP(int p, function<T(T)> f, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = f(tree[i]);
        int mid = (li + ri) / 2;
        return tree[i] = combine(updAtP(p, f, 2*i, li, mid), updAtP(p, f, 2*i+1, mid+1, ri));
    }
};

int dfs(const vector<vector<int>> & tree, int v, int l, int t, vector<int> & levels, vector<int> &tin, vector<int> &tout) {
    levels[v] = l;
    tin[v] = t++;
    for (auto next : tree[v]) {
        t = dfs(tree, next, l+1, t, levels, tin, tout);
    }
    tout[v] = t;
    return t;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> vals(n);
    for (int i = 0; i < n; i++) cin >> vals[i];
    vector<vector<int>> tree(n);
    vector<int> parent(n,-1);
    for (int i = 0; i < n-1; i++) {
        int f, t;
        cin >> f >> t;
        tree[f-1].push_back(t-1);
        parent[t-1] = f-1;
    }
    SegTree<int> additions(0,n-1, [](int x, int y) { return x+y;}, 0);

    vector<int> levels(n);
    vector<int> tin(n);
    vector<int> tout(n);

    dfs(tree, 0, 0, 0, levels, tin, tout);

    for (int i = 0; i < m; i++) {
        int typ, x;
        cin >> typ >> x;
        if (typ == 1) {
            int val;
            cin >> val;
            if (levels[x-1] & 1) val = -val;
            additions.updAt(tin[x-1], [val](int v) {return v+val;});
            additions.updAt(tout[x-1], [val](int v) {return v-val;});
        } else {
            int a = additions.getIn(0,tin[x-1]);
            if (levels[x-1] & 1) a = -a;
            cout << vals[x-1] + a << endl;
        }
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <functional>

using namespace std;

template<class T> class SegTree {
public:
    SegTree(int rmin, int rmax, function<T(T,T)> f, T e) :
        rmin(rmin), rmax(rmax), size(rmax-rmin+1), combine(f), neutral(e), tree(4*size, e) {};
    T getIn(int l, int r) {
        return getInP(max(0,l-rmin), min(size,r-rmin), 1, 0, size);
    }
    void setAt(int p, T v) {
        if (p < rmin || p > rmax) return;
        setAtP(p-rmin, v, 1, 0, size);
    }
    void updAt(int p, function<T(T)> f) {
        updAtP(p-rmin, f, 1, 0, size);
    }
private:
    int size, rmin, rmax;
    T neutral;
    function<T(T,T)> combine;
    vector<T> tree;
    T getInP(int l, int r, int i, int li, int ri) {
        if (l == li && r == ri) return tree[i];
        int mid = (li + ri) / 2;
        if (r <= mid) return getInP(l, r, 2*i, li, mid);
        if (l > mid) return getInP(l, r, 2*i+1, mid+1, ri);
        return combine(getInP(l, mid, 2*i, li, mid), getInP(mid+1, r, 2*i+1, mid+1, ri));
    }
    T setAtP(int p, T v, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = v;
        int mid = (li + ri) / 2;
        return tree[i] = combine(setAtP(p, v, 2*i, li, mid), setAtP(p, v, 2*i+1, mid+1, ri));
    }
    T updAtP(int p, function<T(T)> f, int i, int li, int ri) {
        if (p < li || p > ri) return tree[i];
        if (li == ri) return tree[i] = f(tree[i]);
        int mid = (li + ri) / 2;
        return tree[i] = combine(updAtP(p, f, 2*i, li, mid), updAtP(p, f, 2*i+1, mid+1, ri));
    }
};

template <class T> class BIT {
public:
    BIT(int rmin, int rmax, function<T(T,T)> f, function<T(T,T)> g, T e) :
        rmin(rmin), rmax(rmax), combine(f), reverse(g), size(rmax-rmin+1), tree(size+1, e), neutral(e) {};
    T getUpTo(int x) { return getUpToP(min(size, x - rmin + 1), neutral); }
    T getIn(int l, int r) {
        return reverse(getUpTo(r), getUpTo(l));
    }
    void setAt(int p, T v) {
        T oldV = getIn(p, p);
        T d = reverse(v, oldV);
        updAtWithDiff(p, d);
    }
    void updAt(int p, function<T(T)> f) {
        T oldV = getIn(p, p);
        T d = reverse(f(oldV), oldV);
        updAtWithDiff(p, d);
    }
    void updAtWithDiff(int p, T d) {
        if (p < rmin || p > rmax) return;
        updAtWithDiffP(p - rmin + 1, d);
    }
private:
    int size, rmin, rmax;
    function<T(T,T)> combine;
    function<T(T,T)> reverse;
    T neutral;
    vector<T> tree;
    T getUpToP(int i, T soFar) {
        if (i == 0) return soFar;
        int minBit = i & -i;
        return getUpToP(i ^ minBit, combine(tree[i], soFar));
    }
    void updAtWithDiffP(int p, T d) {
        if (p > size) return;
        tree[p] = combine(tree[p], d);
        int minBit = p & -p;
        updAtWithDiffP(p + minBit, d);
    }
};

int dfs(const vector<vector<int>> & tree, int v, int l, int t, vector<int> & levels, vector<int> &tin, vector<int> &tout) {
    levels[v] = l;
    tin[v] = t++;
    for (auto next : tree[v]) {
        t = dfs(tree, next, l+1, t, levels, tin, tout);
    }
    tout[v] = t;
    return t;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> vals(n);
    for (int i = 0; i < n; i++) cin >> vals[i];
    vector<vector<int>> tree(n);
    for (int i = 0; i < n-1; i++) {
        int f, t;
        cin >> f >> t;
        tree[f-1].push_back(t-1);
    }
//    SegTree<int> additions(0,n, [](int x, int y) { return x+y;}, 0);

    BIT<int> additions(0,n, [](int x, int y) {return x+y;}, [](int x, int y) {return x-y;}, 0);
    vector<int> levels(n);
    vector<int> tin(n);
    vector<int> tout(n);

    dfs(tree, 0, 0, 0, levels, tin, tout);

    for (int i = 0; i < m; i++) {
        int typ, x;
        cin >> typ >> x;
        if (typ == 1) {
            int val;
            cin >> val;
            if (levels[x-1] & 1) val = -val;
            additions.updAtWithDiff(tin[x-1], val);
            additions.updAtWithDiff(tout[x-1], -val);
        } else {
            int a = additions.getUpTo(tin[x-1]);
            if (levels[x-1] & 1) a = -a;
            cout << vals[x-1] + a << endl;
        }
    }
    return 0;
}


/*And I thought my jokes were bad*/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define dbg puts("Viva la vida");
#define CHECK(x) cout << (#x) << " is " << (x) << endl;
#define nl puts("");
#define mp make_pair
#define IN(x) scanf("%d",&x);
#define INL(x) scanf("%lld",&x);
#define OUT(x) printf("%d",x);
#define OUTL(x) printf("%lld",x);
#define MAX 200005
#define MOD 1000000007
#define INF (1 << 31)
#define CASE(x,y) printf("Case %d: %d\n",++x,y);
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);
#define PI acos(-1.0)
#define EPS 1e-19
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define int ll
/*
	when i get older
	i will be stronger
	they'll call me freedom
	just like a waving flag
*/
struct node{
	int val,lazy;
	node()
	{
		val=lazy=0;
	}
};
node tre[3*MAX];

void propagete(int n,int l,int r)
{
	tre[n].val+=tre[n].lazy;//multiply with size for sum
	if(l!=r)
	{
		tre[2*n].lazy+=tre[n].lazy;
		tre[2*n+1].lazy+=tre[n].lazy;
	}
	tre[n].lazy=0;
}
int combine(int a,int b)
{
	return a+b;
}
void update(int n,int l,int r,int i,int j,int val)
{
	propagete(n,l,r);
	if(l>j||r<i) return ;
	if(i<=l&&j>=r)
	{
		tre[n].lazy+=val;
		propagete(n,l,r);
		return ;
	}
	int mid=(l+r)/2;
	update(2*n,l,mid,i,j,val);
	update(2*n+1,mid+1,r,i,j,val);
	tre[n].val=combine(tre[2*n].val,tre[2*n+1].val);

}
int query(int n,int l,int r,int i,int j)
{
	propagete(n,l,r);
	if(l>j||r<i) return 0;
	if(i<=l&&j>=r)
	{
		return tre[n].val;
	}
	int mid=(l+r)/2;
	return combine(query(2*n,l,mid,i,j),query(2*n+1,mid+1,r,i,j));
}

int arr[MAX],lft[MAX],rht[MAX],cur,lvl[MAX];
vector<int> adj[MAX];
void dfs(int n,int par=0)
{
	lft[n]=cur++;
	for(auto &cv:adj[n])
	{
		if(cv==par)
			continue;
		lvl[cv]=lvl[n]+1;
		dfs(cv,n);
	}
	rht[n]=cur-1;
}
void solve()
{
	int i,j,k,l,r,m,n,a,b,c,d,x,y,z,t;
	cin>>n>>m;
	for(i=1;i<=n;i++)
	{
		cin>>arr[i];
	}
	for(i=1;i<n;i++)
	{
		cin>>x>>y;
		adj[x].push_back(y);
		adj[y].push_back(x);
	}
	dfs(1);
	for(i=0;i<m;i++)
	{
		cin>>a;
		if(a==1)
		{
			cin>>x>>y;
			if(lvl[x]&1)
				update(1,0,n-1,lft[x],rht[x],y);
			else
			{
				update(1,0,n-1,lft[x],rht[x],-y);
			}
		}
		else
		{
			cin>>x;
			if(lvl[x]&1)
				cout<<(arr[x]+query(1,0,n-1,lft[x],lft[x]))<<endl;
			else
				cout<<(arr[x]-query(1,0,n-1,lft[x],lft[x]))<<endl;
		}
	}
}
int32_t main()
{
	FASTIO
    int t=1;
    // cin>>t;
    while(t--) solve();
    return 0;
}