#include <bits/stdc++.h>

using namespace std;

#define pb emplace_back
#define rep(i, s, e) for (int i = s; i <= e; ++i)
#define drep(i, s, e) for (int i = s; i >= e; --i)
#define file(a) freopen(#a".in", "r", stdin), freopen(#a".out", "w", stdout)
#define pv(a) cout << #a << " = " << a << endl
#define pa(a, l, r) cout << #a " : "; rep(_, l, r) cout << a[_] << ' '; cout << endl

using ll = long long;
using vi = vector <int>;

const int N = 4e5 + 10;
const int M = 5e3 + 10;

int read() {
  int x = 0, f = 1; char c = getchar();
  for (; c < '0' || c > '9'; c = getchar()) if (c == '-') f = -1;
  for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
  return x * f;
}

mt19937_64 rng(0);
int Rand(int l, int r) {
  return l + rng() % (r - l + 1);
}

int n, cn, m, B, T, lstans, ans;
ll a[N];

set <int> se[N];
vi e[N];
int p[N], dfn[N], dn;
int cnt, col[N], top[M], len[M], id[300][100000], down[M];
ll laz[M];
double dep[N], mx[N];

void Link(int u, int v, int w) {
  a[++ cn] = w;
  se[u].erase(v), se[v].erase(u);
  se[u].insert(cn), se[cn].insert(u);
  se[v].insert(cn), se[cn].insert(v);
  if (p[u] == v) swap(u, v);
  p[v] = cn, p[cn] = u, dep[cn] = (dep[u] + dep[v]) / 2;
  int c = col[v];
  if (c) {
    col[cn] = c, a[cn] -= laz[c], id[c][len[c] + 1] = cn;
    rep(i, 1, len[c]) if (a[cn] <= a[id[c][i]]) {
      drep(j, len[c], i) id[c][j + 1] = id[c][j];
      id[c][i] = cn;
      break;
    }
    ++ len[c];
    rep(i, 1, len[c] - 1) {
      assert(a[id[c][i]] <= a[id[c][i + 1]]);
    }
  }
}

void Add(int u, int w) {
  a[++ cn] = w;
  se[u].insert(cn), se[cn].insert(u);
  p[cn] = u, dep[cn] = dep[u] + 1;
}


void Work(int u, int v, int w, int op) {
  function <void(int)> f, g;
  function <void(int, int)> h;
  auto ask = [&](int u) {
    return a[u] + laz[col[u]];
  } ;
  if (op == 3) {
    f = [&](int u) {
      a[u] += w;
    } ;
    g = [&](int c) {
      laz[c] += w;
    } ;
    h = [&](int u, int v) {
      static bool tag[N];
      int c = col[v];
      for (int w = v; w != u; w = p[w]) f(w), tag[w] = true;
      vector <int> sl, sr;
      drep(i, len[c], 1) {
        if (tag[id[c][i]]) sl.pb(id[c][i]);
        else sr.pb(id[c][i]);
      }
      rep(i, 1, len[c]) {
        if (!sr.size() || (sl.size() && a[sl.back()] <= a[sr.back()])) {
          id[c][i] = sl.back(), sl.pop_back();
        }
        else id[c][i] = sr.back(), sr.pop_back();
      }
      for (int w = v; w != u; w = p[w]) tag[w] = false;
    } ;
  }
  else {
    ans = 0;
    f = [&](int u) {
      ans += ask(u) >= w;
    } ;
    g = [&](int c) {
      int t = partition_point(id[c] + 1, id[c] + len[c] + 1, [&](int i) {
        return ask(i) < w;
      }) - id[c];
      ans += len[c] - t + 1;
    } ;
    h = [&](int u, int v) {
      for (int w = v; w != u; w = p[w]) f(w);
    } ;
  }
  while (!col[u] || !col[v]) {
    if (u == v) return f(u), void();
    if (col[u] || (!col[v] && dep[u] < dep[v])) swap(u, v);
    f(u), u = p[u];
  }
  while (col[u] != col[v]) {
    if (dep[top[col[u]]] < dep[top[col[v]]]) swap(u, v);
    int c = col[u];
    if (u == down[c]) g(c);
    else h(top[c], u);
    u = top[c];
  }
  if (dep[u] < dep[v]) swap(u, v);
  h(p[v], u);
}

void dfs0(int u, int fa) {
  p[u] = fa, mx[u] = dep[u] = dep[fa] + 1, dfn[u] = ++ dn;
  for (int v : e[u]) if (v != fa) {
    dfs0(v, u), mx[u] = max(mx[u], mx[v]);
  }
  if (u == 1 || (mx[u] - dep[u]) * B >= n) col[u] = ++ cnt, mx[u] = dep[u];
}

void dfs1(int u, int fa) {
  int son = 0;
  for (int v : e[u]) if (v != fa) {
    dfs1(v, u);
    if (col[v]) {
      if (col[u] || son) {
        if (!col[u]) col[u] = ++ cnt;
        top[col[son]] = top[col[v]] = u;
      }
      else son = v;
    }
  }
  if (!col[u]) col[u] = col[son];
  else down[col[u]] = u;
}

void rebuild() {
  n = cn, dn = 0;
  rep(c, 1, cnt) {
    rep(i, 1, len[c]) a[id[c][i]] += laz[c];
    len[c] = laz[c] = top[c] = down[c] = 0;
  }
  rep(i, 1, n) {
    p[i] = dfn[i] = dep[i] = col[i] = 0;
    e[i] = vi(se[i].begin(), se[i].end());
  }
  cnt = 0;
  dfs0(1, 0);
  dfs1(1, 0);
  rep(i, 1, n) if (col[i]) {
    id[col[i]][++ len[col[i]]] = i;
  }
  rep(c, 1, cnt) {
    sort(id[c] + 1, id[c] + len[c] + 1, [&](int i, int j) {
      return a[i] < a[j];
    });
    rep(i, 1, len[c]) assert(col[id[c][i]] == c);
  }
}

int main() {
  n = read(), m = read(), cn = n;
  B = sqrt(n / log2(n + 1));
  T = sqrt(n * log2(n + 1));
  rep(i, 1, n) a[i] = read();
  rep(i, 1, n - 1) {
    int u = read(), v = read();
    se[u].insert(v), se[v].insert(u);
  }
  for (int i = 1, j = 0; i <= m; ++ i) {
    if (!j) rebuild(), j = T;
    int op = read();
    if (op == 1) {
      -- j;
      int u = read() ^ lstans, v = read() ^ lstans, w = read() ^ lstans;
      Link(u, v, w);
    }
    else if (op == 2) {
      -- j;
      int u = read() ^ lstans, w = read() ^ lstans;
      Add(u, w);
    }
    else {
      int u = read() ^ lstans, v = read() ^ lstans, w = read() ^ lstans;
      Work(u, v, w, op);
      if (op == 4) printf("%d\n", lstans = ans);
    }
  }
  return 0;
}