#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(int i, T X) {
  return (X & (1 << (i - 1)));
}
template <class T>
T onbit(int i, T X) {
  return (X | (1ll << (i - 1)));
}
template <class T>
T offbit(int i, T X) {
  return (X | (1 << (i - 1)) - (1 << (i - 1)));
}
template <class T>
T sqr(T x) {
  return (x * x);
}
template <class T>
T cube(T x) {
  return (x * x * x);
}
template <class T>
T gcd(T a, T b) {
  T r;
  while (b != 0) {
    r = a % b;
    a = b;
    b = r;
  }
  return a;
}
template <class T>
T lcm(T a, T b) {
  return a / gcd(a, b) * b;
}
int csx[4] = {0, 0, -1, 1};
int csy[4] = {-1, 1, 0, 0};
const int MOD = 1000000007;
const int inf = 1e9;
const long long linf = 1e18;
const int maxn = 4e5 + 5;
int n, m, c[maxn + 5], st[maxn + 5], en[maxn + 5], mark[maxn + 5], ttime = 0,
                                                                   f[maxn + 5];
long long tree[8 * maxn + 5], lz[8 * maxn + 5];
vector<int> adj[maxn + 5];
void enter() {
  int u, v, type;
  scanf("%d %d", &n, &m);
  for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
  for (int i = 1; i <= n - 1; i++) {
    scanf("%d %d", &u, &v);
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
}
void dfs(int u) {
  ttime++;
  f[ttime] = u;
  mark[u] = 1;
  st[u] = ttime;
  int sz = adj[u].size();
  for (int i = 0; i < sz; i++) {
    int v = adj[u][i];
    if (mark[v] == 0) dfs(v);
  }
  en[u] = ttime;
}
long long add(long long a, long long b) { return (a | b); }
void initTree(int i, int l, int r) {
  if (l == r) {
    tree[i] = 1ll << (c[f[l]] - 1);
    return;
  }
  int mid = (l + r) >> 1;
  initTree(2 * i, l, mid);
  initTree(2 * i + 1, mid + 1, r);
  tree[i] = add(tree[2 * i], tree[2 * i + 1]);
}
void update(int i, int l, int r, int u, int v, long long value) {
  if (lz[i] != -1) {
    tree[i] = lz[i];
    lz[2 * i] = lz[i];
    lz[2 * i + 1] = lz[i];
    lz[i] = -1;
  }
  if ((u > r) || (v < l)) return;
  if ((u <= l) && (r <= v)) {
    tree[i] = value;
    lz[i] = -1;
    lz[2 * i] = value;
    lz[2 * i + 1] = value;
    return;
  }
  int mid = (l + r) >> 1;
  update(2 * i, l, mid, u, v, value);
  update(2 * i + 1, mid + 1, r, u, v, value);
  tree[i] = add(tree[2 * i], tree[2 * i + 1]);
}
long long get(int i, int l, int r, int u, int v) {
  if (lz[i] != -1) {
    tree[i] = lz[i];
    lz[2 * i] = lz[i];
    lz[2 * i + 1] = lz[i];
    lz[i] = -1;
  }
  if ((u > r) || (v < l)) return 0;
  if ((u <= l) && (r <= v)) return tree[i];
  int mid = (l + r) >> 1;
  long long left = get(2 * i, l, mid, u, v);
  long long right = get(2 * i + 1, mid + 1, r, u, v);
  long long ans = add(left, right);
  return ans;
}
void solve() {
  int v, c, u, type;
  dfs(1);
  initTree(1, 1, n);
  memset(lz, -1, sizeof(lz));
  for (int q = 1; q <= m; q++) {
    scanf("%d", &type);
    if (type == 1) {
      scanf("%d %d", &v, &c);
      long long value = (1ll << (c - 1));
      update(1, 1, n, st[v], en[v], value);
    } else {
      scanf("%d", &v);
      long long value = get(1, 1, n, st[v], en[v]);
      int ans = __builtin_popcountll(value);
      printf("%d\n", ans);
    }
  }
}
int main() {
  enter();
  solve();
  return 0;
}
