#include <bits/stdc++.h>
static inline int popcount(int x) { return __builtin_popcount(x); }
template <class T, class U>
static inline std::pair<T, U> mp(const T& a, const U& b) {
  return std::make_pair(a, b);
}
static constexpr int INF = std::numeric_limits<int>::max();
static constexpr int MAXN = 2e5 + 10;
static std::vector<int> orig_tree[MAXN];
static int D[MAXN];
static int P[MAXN];
static std::pair<int, int> ranges[MAXN];
static void build_trees(int n = 0, int depth = 0, int par = -1) {
  D[n] = depth;
  P[n] = par;
  static int t[2];
  ranges[n].first = t[depth % 2]++;
  for (int adj : orig_tree[n]) {
    if (adj != par) {
      build_trees(adj, depth + 1, n);
    }
  }
  ranges[n].second = t[depth % 2] - 1;
}
struct node {
  node* left;
  node* right;
  int start;
  int end;
  int sum;
  node() : left(nullptr), right(nullptr), start(0), end(0), sum(0) {}
  void push() {
    left->sum += sum;
    right->sum += sum;
    sum = 0;
  }
  void update(int rs, int re, int val) {
    if (start > re || end < rs) return;
    if (start >= rs && end <= re) {
      sum += val;
      return;
    }
    left->update(rs, re, val);
    right->update(rs, re, val);
  }
  int query(int idx) {
    if (start == end) return sum;
    const int mid = (start + end) / 2;
    push();
    if (idx <= mid) return left->query(idx);
    return right->query(idx);
  }
};
static node* build_tree(int left, int right) {
  node* result = new node;
  result->start = left;
  result->end = right;
  if (left == right) return result;
  result->left = build_tree(left, (left + right) / 2);
  result->right = build_tree((left + right) / 2 + 1, right);
  return result;
}
int main() {
  int nodes, queries;
  std::scanf("%d %d", &nodes, &queries);
  static int orig_vals[MAXN];
  for (int i = 0; i < nodes; i++) std::scanf("%d", orig_vals + i);
  for (int i = 0; i + 1 < nodes; i++) {
    int src, dest;
    std::scanf("%d %d", &src, &dest);
    src--, dest--;
    orig_tree[src].push_back(dest);
    orig_tree[dest].push_back(src);
  }
  build_trees();
  node* st[2];
  st[0] = build_tree(0, nodes - 1);
  st[1] = build_tree(0, nodes - 1);
  static int extra[MAXN];
  for (int i = 0; i < queries; i++) {
    int type;
    std::scanf("%d", &type);
    if (type == 1) {
      int vertex, value;
      std::scanf("%d %d", &vertex, &value);
      vertex--;
      int par = D[vertex] % 2;
      st[par]->update(ranges[vertex].first, ranges[vertex].second, value);
      for (int adj : orig_tree[vertex]) {
        if (D[adj] < D[vertex]) continue;
        st[1 - par]->update(ranges[adj].first, ranges[adj].second, -value);
      }
    } else {
      int vertex;
      std::scanf("%d", &vertex);
      vertex--;
      int par = D[vertex] % 2;
      std::printf("%d\n", st[par]->query(ranges[vertex].first) +
                              orig_vals[vertex] - extra[vertex]);
    }
  }
  return 0;
}
