#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const long long inf = 1e17;
int n, m, q;
int numChain[N], curChain = 1, top = 0, par[N];
int pos[N], Moe_algorithm___Too_moe_not_to_read[N], ar[N], heavyChild[N],
    size[N], head[N];
long long lazy[4 * N];
vector<int> G[N];
pair<long long, int> IT[4 * N];
list<pair<long long, int> > GLive[N];
void DFS(int u, int v) {
  size[u] = 1;
  par[u] = v;
  for (int p : G[u]) {
    if (p == v) continue;
    DFS(p, u);
    if (size[p] > size[heavyChild[u]]) heavyChild[u] = p;
    size[u] += size[p];
  }
}
void hld(int u) {
  numChain[u] = curChain;
  pos[u] = Moe_algorithm___Too_moe_not_to_read[u] = ++top;
  ar[top] = u;
  if (not head[curChain]) head[curChain] = u;
  if (heavyChild[u])
    hld(heavyChild[u]), Moe_algorithm___Too_moe_not_to_read[u] =
                            Moe_algorithm___Too_moe_not_to_read[heavyChild[u]];
  for (int p : G[u]) {
    if (par[p] == u && p != heavyChild[u]) {
      curChain++;
      hld(p);
      Moe_algorithm___Too_moe_not_to_read[u] =
          Moe_algorithm___Too_moe_not_to_read[p];
    }
  }
}
void build(int id, int l, int r) {
  if (l == r) {
    IT[id] = {GLive[ar[l]].begin()->first, ar[l]};
    return;
  }
  int mid = (l + r) >> 1;
  build(id << 1, l, mid);
  build((id << 1) | 1, mid + 1, r);
  IT[id] = min(IT[id << 1], IT[(id << 1) | 1]);
}
void down(int id, int l, int mid, int r) {
  lazy[id << 1] += lazy[id];
  lazy[(id << 1) | 1] += lazy[id];
  IT[(id << 1)].first += lazy[id];
  IT[(id << 1) | 1].first += lazy[id];
  lazy[id] = 0;
}
void upd(int id, int l, int r, int L, int R, long long val) {
  if (l > R || r < L) return;
  if (l >= L && r <= R) {
    lazy[id] += val;
    IT[id].first += val;
    return;
  }
  int mid = (l + r) >> 1;
  if (lazy[id] != 0) down(id, l, mid, r);
  upd(id << 1, l, mid, L, R, val);
  upd((id << 1) | 1, mid + 1, r, L, R, val);
  IT[id] = min(IT[id << 1], IT[(id << 1) | 1]);
}
pair<long long, int> GET(int id, int l, int r, int L, int R) {
  if (l > R || r < L) return {inf, 0};
  if (l >= L && r <= R) return IT[id];
  int mid = (l + r) >> 1;
  if (lazy[id] != 0) down(id, l, mid, r);
  return min(GET(id << 1, l, mid, L, R), GET((id << 1) | 1, mid + 1, r, L, R));
}
pair<long long, int> PATH(int u, int v) {
  pair<long long, int> ans = {inf, 0};
  while (numChain[u] != numChain[v]) {
    if (numChain[u] < numChain[v]) swap(u, v);
    ans = min(ans, GET(1, 1, n, pos[head[numChain[u]]], pos[u]));
    u = par[head[numChain[u]]];
  }
  return min(ans, GET(1, 1, n, min(pos[u], pos[v]), max(pos[u], pos[v])));
}
int main() {
  scanf("%d %d %d", &n, &m, &q);
  for (int i = 1; i < n; i++) {
    int u, v;
    scanf("%d %d", &u, &v);
    G[u].push_back(v);
    G[v].push_back(u);
  }
  DFS(1, 0);
  hld(1);
  for (int i = 1; i <= 4 * n; i++) IT[i] = {inf, inf};
  for (int i = 1; i <= m; i++) {
    int u;
    scanf("%d", &u);
    GLive[u].push_back({i, i});
  }
  for (int i = 1; i <= n; i++) GLive[i].push_back({inf, 0});
  build(1, 1, n);
  while (q--) {
    int type, u;
    scanf("%d %d", &type, &u);
    if (type == 1) {
      int v, k;
      scanf("%d %d", &v, &k);
      vector<int> ans;
      for (int i = 0; i < k; i++) {
        pair<long long, int> tmp = PATH(u, v);
        if (tmp.first < inf) {
          int node = tmp.second;
          ans.push_back(GLive[node].begin()->second);
          upd(1, 1, n, pos[node], pos[node], -(GLive[node].begin()->first));
          GLive[node].pop_front();
          upd(1, 1, n, pos[node], pos[node], GLive[node].begin()->first);
        } else
          break;
      }
      printf("%d ", ans.size());
      for (int i : ans) printf("%d ", i);
      printf("\n");
    } else {
      long long val;
      scanf("%lld", &val);
      upd(1, 1, n, pos[u], Moe_algorithm___Too_moe_not_to_read[u], val);
    }
  }
}
