#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
const int N = 2e5 + 100;
const long long inf = 1LL << 60;
int q[N], hs[N], heavy[N], d[N], id[N];
int L[N], R[N];
int ziggy[N], s[N], f[N], pos[N], mars[N];
int n, m, tot, u, v, k, ty;
vector<int> gfo[N], vec[N], ret;
pair<long long, int> ind[N], z;
inline long long rd() {
  long long x = 0;
  int ch = getchar(), f = 1;
  while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
  if (ch == '-') {
    f = -1;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = (x << 1) + (x << 3) + ch - '0';
    ch = getchar();
  }
  return x * f;
}
struct node {
  long long fg;
  pair<long long, int> s;
} nd[4 * N];
inline void update(int p) { nd[p].s = min(nd[p + p].s, nd[p + p + 1].s); }
inline void set_fi(int p, long long v) {
  nd[p].fg += v;
  nd[p].s.first += v;
}
inline void build(int p, int l, int r) {
  nd[p].fg = 0;
  if (l == r)
    nd[p].s = ind[l];
  else {
    int md = (l + r) >> 1;
    build(p + p, l, md);
    build(p + p + 1, md + 1, r);
    update(p);
  }
}
inline void push(int p) {
  if (nd[p].fg) {
    set_fi(p + p, nd[p].fg);
    set_fi(p + p + 1, nd[p].fg);
    nd[p].fg = 0;
  }
}
inline pair<long long, int> query(int p, int l, int r, int tl, int tr) {
  if (tl == l && tr == r)
    return nd[p].s;
  else {
    push(p);
    int md = (l + r) >> 1;
    if (tr <= md)
      return query(p + p, l, md, tl, tr);
    else if (tl > md)
      return query(p + p + 1, md + 1, r, tl, tr);
    else
      return min(query(p + p, l, md, tl, md),
                 query(p + p + 1, md + 1, r, md + 1, tr));
  }
}
inline void modify(int p, int l, int r, int tl, int tr, long long v) {
  if (tl > tr) return;
  if (tl == l && tr == r)
    return set_fi(p, v);
  else {
    push(p);
    int md = (l + r) >> 1;
    if (tr <= md)
      modify(p + p, l, md, tl, tr, v);
    else if (tl > md)
      modify(p + p + 1, md + 1, r, tl, tr, v);
    else {
      modify(p + p, l, md, tl, md, v);
      modify(p + p + 1, md + 1, r, md + 1, tr, v);
    }
    update(p);
  }
}
inline void dfs(int u, int f) {
  id[L[u] = ++tot] = u;
  ind[tot] = {inf, 0};
  for (int v : vec[u]) {
    ind[++tot] = {v, v};
    pos[v] = tot;
  }
  mars[u] = tot;
  d[u] = d[f] + 1;
  if (heavy[u]) dfs(heavy[u], u);
  for (int j = int(0); j < int(int(gfo[u].size())); ++j)
    if (gfo[u][j] != f && gfo[u][j] != heavy[u]) dfs(gfo[u][j], u);
  R[u] = tot;
}
inline void init(int rt) {
  int t = 1;
  q[0] = rt;
  for (int i = int(0); i < int(n); ++i) {
    int u = q[i];
    for (int j = int(0); j < int(int(gfo[u].size())); ++j)
      if (gfo[u][j] != f[u]) f[gfo[u][j]] = u, d[q[t++] = gfo[u][j]] = d[u] + 1;
  }
  for (int i = int(n - 1); i >= int(0); i--) {
    int u = q[i], p = f[u];
    s[u]++, s[p] += s[u];
    if (!L[u]) L[u] = 1;
    if (hs[p] < s[u]) hs[p] = s[u], heavy[p] = u, L[p] = L[u] + 1;
  }
  for (int i = int(0); i < int(n); ++i) {
    int u = q[i];
    if (!ziggy[u]) ziggy[u] = u;
    if (heavy[u]) ziggy[heavy[u]] = ziggy[u];
  }
  dfs(rt, 0);
}
inline void query(int u, int v) {
  while (1) {
    if (ziggy[u] == ziggy[v]) {
      if (d[u] < d[v]) swap(u, v);
      z = min(z, query(1, 1, m, L[v], mars[u]));
      break;
    } else {
      if (d[ziggy[u]] < d[ziggy[v]]) swap(u, v);
      z = min(z, query(1, 1, m, L[ziggy[u]], mars[u]));
      u = f[ziggy[u]];
    }
  }
}
int main() {
  int q;
  n = rd();
  m = rd();
  q = rd();
  for (int i = int(1); i < int(n); ++i) {
    u = rd();
    v = rd();
    gfo[u].push_back(v);
    gfo[v].push_back(u);
  }
  for (int i = int(0); i < int(m); ++i) {
    u = rd();
    vec[u].push_back(i + 1);
  }
  init(1);
  m = tot;
  build(1, 1, m);
  for (int i = int(0); i < int(q); ++i) {
    ty = rd();
    if (ty == 1) {
      u = rd();
      v = rd();
      k = rd();
      ret.clear();
      while (k > 0) {
        z = {inf, 0};
        query(u, v);
        if (z.first >= 1LL << 50) break;
        --k;
        ret.push_back(z.second);
        modify(1, 1, m, pos[z.second], pos[z.second], inf);
      }
      printf("%d", int(ret.size()));
      for (auto u : ret) printf(" %d", u);
      puts("");
    } else {
      u = rd();
      k = rd();
      modify(1, 1, m, L[u], R[u], k);
    }
  }
}
