#include <bits/stdc++.h>
using namespace std;
long long int mod1 = 998244353, mod2 = (long long int)1e9 + 7;
long long int power(long long int n, long long int k, long long int mod) {
  long long int ans = 1;
  n = n % mod;
  while (k > 0) {
    if (k & 1) ans = (ans * n) % mod;
    n = (n * n) % mod;
    k >>= 1;
  }
  return (ans + mod) % mod;
}
struct triplet {
  long long int a, b, c;
};
bool operator<(const triplet &t1, const triplet &t2) {
  if (t1.a < t2.a) return true;
  if (t1.a == t2.a && t1.b < t2.b) return true;
  if (t1.a == t2.a && t1.b == t2.b && t1.c < t2.c) return true;
  return false;
}
long long int T[(long long int)4e6 + 5], second[(long long int)4e6 + 5],
    E[(long long int)4e6 + 5], lazy[(long long int)4e6 + 5],
    A[(long long int)4e6 + 5];
vector<long long int> g[200005];
vector<pair<long long int, long long int> > range(200005);
long long int timer = 0;
long long int level[200005];
void dfs(long long int cur, long long int par, long long int lev = 0) {
  range[cur].first = timer++;
  level[cur] = lev;
  for (auto i : g[cur]) {
    if (i != par) {
      dfs(i, cur, lev + 1);
    }
  }
  range[cur].second = timer - 1;
}
long long int calculate(long long int node) {
  return (T[node] + lazy[node] * (E[node] - second[node] + 1));
}
void lazypropagation(long long int node) {
  lazy[2 * node] += lazy[node];
  lazy[2 * node + 1] += lazy[node];
  lazy[node] = 0;
}
void build(long long int node, long long int l, long long int r) {
  second[node] = l;
  E[node] = r;
  if (l == r) {
    T[node] = A[l];
    return;
  }
  long long int mid = (l + r) / 2;
  build(2 * node, l, mid);
  build(2 * node + 1, mid + 1, r);
  T[node] = T[2 * node] + T[2 * node + 1];
  return;
}
void update(long long int node, long long int l, long long int r,
            long long int x) {
  if ((second[node] > r) || (E[node] < l)) return;
  if ((second[node] >= l) && (E[node] <= r)) {
    lazy[node] += x;
    return;
  }
  lazypropagation(node);
  update(2 * node, l, r, x);
  update(2 * node + 1, l, r, x);
  T[node] = calculate(2 * node) + calculate(2 * node + 1);
}
long long int query(long long int node, long long int l, long long int r) {
  if (second[node] > r || E[node] < l) return 0;
  if (second[node] >= l && E[node] <= r) return calculate(node);
  lazypropagation(node);
  long long int left = query(2 * node, l, r);
  long long int right = query(2 * node + 1, l, r);
  T[node] = calculate(2 * node) + calculate(2 * node + 1);
  return (left + right);
}
int32_t main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long int t = 1;
  while (t--) {
    long long int n, m;
    cin >> n >> m;
    long long int a[n];
    for (long long int i = 0; i < n; i++) cin >> a[i];
    for (long long int i = 0; i < n - 1; i++) {
      long long int u, v;
      cin >> u >> v;
      g[u].push_back(v);
      g[v].push_back(u);
    }
    build(1, 0, n - 1);
    dfs(1, 0);
    for (long long int i = 0; i < m; i++) {
      long long int qtype, x, val;
      cin >> qtype >> x;
      if (qtype == 1) {
        cin >> val;
        if (level[x] & 1) val = -val;
        update(1, range[x].first, range[x].second, -val);
      } else {
        long long int ans = query(1, range[x].first, range[x].first);
        if (level[x] & 1) ans = -ans;
        cout << -ans + a[x - 1] << "\n";
      }
    }
  }
}
