#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15;
long long n, m, q, x, y, sz[100002], t[100002], lvl[100002], dfsP[100002],
    heavy[100002], nr, en[100002], aux, lazy[400002];
pair<long long, pair<long long, long long> > aint[400002];
vector<int> g[100002];
pair<long long, pair<long long, long long> > val[100002];
vector<long long> s[100002];
void prop(int nod, long long st, long long dr) {
  if (st > dr || !lazy[nod]) return;
  aint[nod].first += lazy[nod];
  if (st != dr) {
    lazy[2 * nod] += lazy[nod];
    lazy[2 * nod + 1] += lazy[nod];
  }
  lazy[nod] = 0;
}
pair<long long, pair<long long, long long> > query(long long nod, long long st,
                                                   long long dr, long long a,
                                                   long long b) {
  prop(nod, st, dr);
  if (st > dr || dr < a || b < st) return {INF, {0, 0}};
  if (a <= st && dr <= b) {
    return aint[nod];
  }
  pair<long long, pair<long long, long long> > ans = {INF, {0, 0}};
  long long mid = (st + dr) / 2;
  ans = min(ans, query(2 * nod, st, mid, a, b));
  ans = min(ans, query(2 * nod + 1, mid + 1, dr, a, b));
  return ans;
}
void build(long long nod, long long st, long long dr) {
  if (st == dr) {
    aint[nod] = val[st];
    return;
  }
  long long mid = (st + dr) / 2;
  build(2 * nod, st, mid);
  build(2 * nod + 1, mid + 1, dr);
  aint[nod] = min(aint[2 * nod], aint[2 * nod + 1]);
}
void update(long long nod, long long st, long long dr, long long a, long long b,
            long long val, long long t) {
  prop(nod, st, dr);
  if (st > dr || dr < a || b < st) return;
  if (a <= st && dr <= b) {
    if (t) {
      aint[nod] = {val, {aint[nod].second.first, t}};
    } else {
      aint[nod].first += val;
      if (st != dr) {
        lazy[2 * nod] += val;
        lazy[2 * nod + 1] += val;
      }
    }
    return;
  }
  long long mid = (st + dr) / 2;
  update(2 * nod, st, mid, a, b, val, t);
  update(2 * nod + 1, mid + 1, dr, a, b, val, t);
  aint[nod] = min(aint[2 * nod], aint[2 * nod + 1]);
}
void dfs1(long long x, long long p) {
  sz[x] = 1;
  for (auto it : g[x]) {
    if (it == p) continue;
    t[it] = x;
    lvl[it] = lvl[x] + 1;
    dfs1(it, x);
    sz[x] += sz[it];
  }
}
void dfs2(long long x, long long p) {
  dfsP[x] = ++nr;
  val[nr] = {s[x][0], {1ll * x, 0ll}};
  long long child = 0, mx = 0;
  for (auto it : g[x]) {
    if (it == p) continue;
    if (mx < sz[it]) {
      mx = sz[it];
      child = it;
    }
  }
  heavy[child] = heavy[x];
  if (child) dfs2(child, x);
  for (auto it : g[x]) {
    if (it == p) continue;
    if (it != child) {
      heavy[it] = it;
      dfs2(it, x);
    }
  }
  en[x] = nr;
}
pair<long long, pair<long long, long long> > queryMaxswap(long long u,
                                                          long long v) {
  if (v < u) swap(u, v);
  return query(1, 1, n, u, v);
}
pair<long long, pair<long long, long long> > solve(long long u, long long v) {
  pair<long long, pair<long long, long long> > ans = {INF, {0, 0}};
  if (heavy[u] == heavy[v]) {
    ans = queryMaxswap(dfsP[u], dfsP[v]);
  } else {
    if (lvl[heavy[u]] > lvl[heavy[v]]) {
      ans = query(1, 1, n, dfsP[heavy[u]], dfsP[u]);
      u = t[heavy[u]];
    } else {
      ans = query(1, 1, n, dfsP[heavy[v]], dfsP[v]);
      v = t[heavy[v]];
    }
    ans = min(ans, solve(u, v));
  }
  return ans;
}
int main() {
  cin >> n >> m >> q;
  for (long long i = 1; i < n; i++) {
    long long x, y;
    cin >> x >> y;
    g[x].push_back(y);
    g[y].push_back(x);
  }
  for (long long i = 1; i <= m; i++) {
    long long x;
    cin >> x;
    s[x].push_back(1ll * i);
  }
  for (long long i = 1; i <= n; i++) s[i].push_back(INF);
  for (long long i = 1; i <= n; i++) sort(s[i].begin(), s[i].end());
  dfs1(1, 0);
  heavy[1] = 1;
  dfs2(1, 0);
  build(1, 1, n);
  while (q--) {
    long long t;
    long long x, y, k;
    cin >> t;
    if (t == 1) {
      cin >> x >> y >> k;
      if (aux >= m) {
        cout << "0\n";
        continue;
      }
      vector<long long> res;
      for (long long i = 1; i <= k; i++) {
        pair<long long, pair<long long, long long> > c = solve(x, y);
        if (c.first < INF && c.second.first <= n) {
          res.push_back(s[c.second.first][c.second.second]);
          long long cost;
          if (c.second.second == s[c.second.first].size() - 1)
            cost = INF;
          else {
            cost = c.first - s[c.second.first][c.second.second];
            c.second.second++;
            cost += 1ll * s[c.second.first][c.second.second];
          }
          update(1, 1, n, dfsP[c.second.first], dfsP[c.second.first], cost,
                 c.second.second);
        } else
          break;
      }
      aux += res.size();
      cout << res.size() << " ";
      for (auto it : res) cout << it << " ";
      cout << "\n";
    } else {
      cin >> x >> k;
      if (aux >= m) continue;
      update(1, 1, n, dfsP[x], en[x], k, 0);
    }
  }
  return 0;
}
