#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, q, fst[N], to[N << 1], nxt[N << 1], order[N << 1], tote, tott, dfn,
    st[N], tin[N], tout[N], pa[N], h[N], sub[N], Min[N << 1][18], Log[N << 1],
    head[N], pos[N], sz[N];
long long bit[N];
vector<int> chicks[N];
template <class T>
inline void RD(T &a) {
  register int ch = getchar();
  bool ng = 0;
  for (; ch < '0' || ch > '9'; ch = getchar())
    if (ch == '-') ng = 1;
  for (a = 0; ch >= '0' && ch <= '9'; ch = getchar())
    a = (a << 1) + (a << 3) + (ch ^ '0');
  if (ng) a = ~a + 1;
}
template <class T>
inline void WT(T a) {
  if (a < 0)
    putchar('-'), WT(~a + 1);
  else {
    if (a > 9) WT(a / 10);
    putchar(a % 10 ^ '0');
  }
}
inline void upd(int p, int x) {
  for (; p <= n; p += p & (-p)) bit[p] += x;
}
inline long long getS(int p) {
  long long res = 0;
  for (; p; p -= p & (-p)) res += bit[p];
  return res;
}
struct node {
  int pos;
  long long minVal;
  node() {}
  node(int pos, long long minVal) : pos(pos), minVal(minVal) {}
  bool operator<(const node &o) const {
    if (minVal != o.minVal) return minVal < o.minVal;
    return pos < o.pos;
  }
};
struct MinTree {
  vector<node> seg;
  vector<long long> lazy, extra;
  vector<int> toV;
  MinTree() {}
  MinTree(int SZ) {
    seg.resize((SZ << 2) + 1), lazy.resize((SZ << 2) + 1);
    toV.resize(SZ + 1), extra.resize(SZ + 1);
  }
  inline void push(int id, int L, int R) {
    if (L > R || !lazy[id]) return;
    if (L != R) {
      lazy[id << 1] += lazy[id];
      lazy[id << 1 | 1] += lazy[id];
    }
    seg[id].minVal += lazy[id];
    if (L == R) extra[L] += lazy[id];
    lazy[id] = 0;
  }
  inline void build(int id, int L, int R) {
    if (L > R) return;
    if (L == R) {
      seg[id].pos = toV[L], lazy[id] = extra[L] = 0;
      if (chicks[toV[L]].empty())
        seg[id] = node(1e9, 1e15);
      else
        seg[id].minVal = chicks[toV[L]].back();
      return;
    }
    build(id << 1, L, ((L + R) >> 1)),
        build(id << 1 | 1, ((L + R) >> 1) + 1, R);
    seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
  }
  inline void del(const int &p, int id, int L, int R) {
    push(id, L, R);
    if (L > R || p < L || p > R) return;
    if (L == R) {
      chicks[toV[L]].pop_back();
      if (chicks[toV[L]].empty())
        seg[id] = node(1e9, 1e15);
      else
        seg[id].minVal = chicks[toV[L]].back() + extra[L];
      return;
    }
    del(p, id << 1, L, ((L + R) >> 1)),
        del(p, id << 1 | 1, ((L + R) >> 1) + 1, R);
    seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
  }
  inline void incR(const int &u, const int &v, const int &c, int id, int L,
                   int R) {
    push(id, L, R);
    if (L > R || u > R || v < L) return;
    if (u <= L && R <= v) {
      lazy[id] += c, push(id, L, R);
      return;
    }
    incR(u, v, c, id << 1, L, ((L + R) >> 1)),
        incR(u, v, c, id << 1 | 1, ((L + R) >> 1) + 1, R);
    seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
  }
  inline node getR(const int &u, const int &v, int id, int L, int R) {
    push(id, L, R);
    if (L > R || u > R || v < L) return node(1e9, 1e15);
    if (u <= L && R <= v) return seg[id];
    return min(getR(u, v, id << 1, L, ((L + R) >> 1)),
               getR(u, v, id << 1 | 1, ((L + R) >> 1) + 1, R));
  }
} tree[N];
inline void addE(int u, int v) {
  nxt[++tote] = fst[u], fst[u] = tote, to[tote] = v;
}
inline void dfs(int u) {
  order[++tott] = u, st[u] = tott, sub[u] = 1;
  tin[u] = ++dfn;
  for (int i = fst[u]; i; i = nxt[i])
    if (to[i] != pa[u]) {
      pa[to[i]] = u, h[to[i]] = h[u] + 1, dfs(to[i]);
      sub[u] += sub[to[i]];
      order[++tott] = u;
    }
  tout[u] = dfn;
}
inline int getMin(int u, int v) { return h[u] < h[v] ? u : v; }
void DP() {
  Log[1] = 0;
  for (int i(2), b_(tott); i <= b_; ++i) Log[i] = Log[i >> 1] + 1;
  for (int i(1), b_(tott); i <= b_; ++i) Min[i][0] = order[i];
  for (int j(1), b_(Log[tott]); j <= b_; ++j)
    for (int i(1), b_(tott - (1 << j) + 1); i <= b_; ++i)
      Min[i][j] = getMin(Min[i][j - 1], Min[i + (1 << (j - 1))][j - 1]);
}
inline int lca(int u, int v) {
  if (st[u] > st[v]) swap(u, v);
  int k = Log[st[v] - st[u] + 1];
  return getMin(Min[st[u]][k], Min[st[v] - (1 << k) + 1][k]);
}
inline void hld(int u) {
  int id = 0;
  for (int i = fst[u]; i; i = nxt[i])
    if (to[i] != pa[u]) {
      if (sub[to[i]] > sub[id] || !id) id = to[i];
    }
  if (id) {
    head[id] = head[u], pos[id] = pos[u] + 1;
    ++sz[head[u]];
    hld(id);
  }
  for (int i = fst[u]; i; i = nxt[i])
    if (to[i] != pa[u]) {
      if (to[i] == id) continue;
      head[to[i]] = to[i], pos[to[i]] = sz[to[i]] = 1;
      hld(to[i]);
    }
}
inline node subPath(int u, int a) {
  node res(1e9, 1e15);
  while (head[u] != head[a]) {
    node G = tree[head[u]].getR(1, pos[u], 1, 1, sz[head[u]]);
    res = min(res, node(G.pos, G.minVal + getS(tin[head[u]])));
    u = pa[head[u]];
  }
  node G = tree[head[a]].getR(pos[a], pos[u], 1, 1, sz[head[a]]);
  res = min(res, node(G.pos, G.minVal + getS(tin[head[a]])));
  return res;
}
void init() {
  RD(n), RD(m), RD(q);
  for (int i(1), b_(n - 1); i <= b_; ++i) {
    int u, v;
    RD(u), RD(v);
    addE(u, v), addE(v, u);
  }
  for (int i(1), b_(m); i <= b_; ++i) {
    int x;
    RD(x);
    chicks[x].emplace_back(i);
  }
  for (int i(1), b_(n); i <= b_; ++i)
    reverse(chicks[i].begin(), chicks[i].end());
  head[1] = pos[1] = sz[1] = 1;
  dfs(1), DP(), hld(1);
  for (int i(1), b_(n); i <= b_; ++i)
    if (head[i] == i) {
      tree[i] = MinTree(sz[i]);
    }
  for (int i(1), b_(n); i <= b_; ++i) tree[head[i]].toV[pos[i]] = i;
  for (int i(1), b_(n); i <= b_; ++i)
    if (head[i] == i) {
      tree[i].build(1, 1, sz[i]);
    }
}
void process() {
  while (q--) {
    int t;
    RD(t);
    if (t == 1) {
      int u, v, k;
      RD(u), RD(v), RD(k);
      vector<int> ans;
      while (k--) {
        int anc = lca(u, v);
        node G = min(subPath(u, anc), subPath(v, anc));
        if (G.minVal >= 1e15) break;
        ans.emplace_back(chicks[G.pos].back());
        tree[head[G.pos]].del(pos[G.pos], 1, 1, sz[head[G.pos]]);
      }
      WT((int)ans.size()), putchar(' ');
      for (int g : ans) WT(g), putchar(' ');
      puts("");
    } else {
      int v, k;
      RD(v), RD(k);
      if (head[v] != v)
        tree[head[v]].incR(pos[v], sz[head[v]], k, 1, 1, sz[head[v]]);
      upd(tin[v], k), upd(tout[v] + 1, -k);
    }
  }
}
int main() {
  init();
  process();
  return 0;
}
