#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int tinf = (int)1e9 + 7;
const long long inf = (long long)1e18 + 7;
const int N = 5e5 + 5;
const long long M = 1e9 + 7;
const int rx[4] = {1, 0, -1, 0};
const int ry[4] = {0, 1, 0, -1};
int depth[N];
struct SegTree {
  vector<int> t[2], a, add[2], need[2], cnt[2], vertex;
  int n;
  SegTree(int _n, vector<int> _a, vector<int> _vertex) : n(_n), a(_n) {
    for (int i = 0; i < 2; i++) {
      need[i].resize(n * 4);
      add[i].resize(n * 4);
      cnt[i].resize(n * 4);
      t[i].resize(n * 4);
    }
    a = _a;
    vertex = _vertex;
    build(1, 0, n - 1);
  }
  void build(int v, int tl, int tr) {
    if (tl == tr) {
      if (depth[vertex[tl]] % 2 == 0) {
        t[0][v] = a[tl];
        cnt[0][v] = 1;
      } else if (depth[vertex[tl]] % 2) {
        t[1][v] = a[tl];
        cnt[1][v] = 1;
      }
    } else {
      int tm = (tl + tr) >> 1;
      build(v * 2, tl, tm);
      build(v * 2 + 1, tm + 1, tr);
      for (int e = 0; e < 2; e++) {
        t[e][v] = t[e][v * 2] + t[e][v * 2 + 1];
        cnt[e][v] = cnt[e][v * 2] + cnt[e][v * 2 + 1];
      }
    }
  }
  void push(int v, int tl, int tr, bool e) {
    if (!need[e][v]) return;
    t[e][v] += cnt[e][v] * add[e][v];
    if (tl != tr) {
      need[e][v * 2] = need[e][v * 2 + 1] = 1;
      add[e][v * 2] += add[e][v];
      add[e][v * 2 + 1] += add[e][v];
    }
    add[e][v] = 0;
    need[e][v] = 0;
  }
  void update(int v, int tl, int tr, int l, int r, int val, bool e) {
    push(v, tl, tr, e), push(v, tl, tr, 1 - e);
    if (l > r) return;
    if (tl == l && tr == r) {
      add[e][v] += val;
      need[e][v] = 1;
      push(v, tl, tr, e), push(v, tl, tr, 1 - e);
    } else {
      int tm = (tl + tr) >> 1;
      update(v * 2, tl, tm, l, min(tm, r), val, e);
      update(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, val, e);
      t[e][v] = t[e][v * 2] + t[e][v * 2 + 1];
    }
  }
  int Sum(int v, int tl, int tr, int l, int r, bool e) {
    push(v, tl, tr, e), push(v, tl, tr, 1 - e);
    if (l > r) return 0;
    if (tl == l && tr == r) {
      return t[e][v];
    }
    int tm = (tl + tr) >> 1;
    return Sum(v * 2, tl, tm, l, min(tm, r), e) +
           Sum(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, e);
  }
};
vector<int> g[N];
bool used[N];
int tin[N], tout[N], timer;
vector<int> vertex;
void dfs(int v, int d = 1) {
  used[v] = true;
  vertex.push_back(v);
  tin[v] = timer++;
  depth[v] = d;
  for (auto j : g[v]) {
    if (!used[j]) {
      dfs(j, d + 1);
    }
  }
  tout[v] = timer - 1;
}
signed main() {
  {
    ios ::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
  }
  int n, m;
  cin >> n >> m;
  int a[n];
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  for (int i = 1; i < n; i++) {
    int v, u;
    cin >> v >> u;
    v--;
    u--;
    g[v].push_back(u);
    g[u].push_back(v);
  }
  dfs(0);
  vector<int> vecnew(n);
  for (int i = 0; i < n; i++) {
    vecnew[i] = a[vertex[i]];
  }
  SegTree seg(n, vecnew, vertex);
  for (int i = 0; i < m; i++) {
    int t;
    cin >> t;
    if (t == 1) {
      int v, val;
      cin >> v >> val;
      v--;
      bool e = depth[v] % 2;
      seg.update(1, 0, n - 1, tin[v], tout[v], val, e);
      seg.update(1, 0, n - 1, tin[v], tout[v], -val, 1 - e);
    } else {
      int v;
      cin >> v;
      v--;
      cout << seg.Sum(1, 0, n - 1, tin[v], tin[v], depth[v] % 2) << '\n';
    }
  }
}
