#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAXN = 200007;
const int LOGN = 18;
vector<int> edg[MAXN];
int sbtr[MAXN], lvl[MAXN], pr[MAXN][LOGN];
int chainIdx[MAXN], chainHead[MAXN], chainTail[MAXN], flatIdx[MAXN], flat[MAXN];
int chainCnt, flatCnt;
void dfs(int u, int p) {
  lvl[u] = lvl[p] + 1;
  pr[u][0] = p;
  for (int k = 1; k < LOGN; k++) {
    pr[u][k] = pr[pr[u][k - 1]][k - 1];
  }
  sbtr[u] = 1;
  for (int v : edg[u]) {
    if (v == p) continue;
    dfs(v, u);
    sbtr[u] += sbtr[v];
  }
}
int getLCA(int u, int v) {
  if (lvl[u] < lvl[v]) swap(u, v);
  for (int k = LOGN - 1; k >= 0; k--) {
    if (lvl[u] - (1 << k) >= lvl[v]) {
      u = pr[u][k];
    }
  }
  if (u == v) return u;
  for (int k = LOGN - 1; k >= 0; k--) {
    if (pr[u][k] != pr[v][k]) {
      u = pr[u][k];
      v = pr[v][k];
    }
  }
  return pr[u][0];
}
void HLD(int u, int p) {
  chainIdx[u] = chainCnt;
  chainTail[chainCnt] = u;
  flatIdx[u] = flatCnt;
  flat[flatCnt] = u;
  flatCnt++;
  int biggie = -1, mx = 0;
  for (int v : edg[u]) {
    if (v == p) continue;
    if (mx < sbtr[v]) {
      mx = sbtr[v];
      biggie = v;
    }
  }
  if (biggie == -1) return;
  HLD(biggie, u);
  for (int v : edg[u]) {
    if (v == p || v == biggie) continue;
    chainCnt++;
    chainHead[chainCnt] = v;
    HLD(v, u);
  }
}
void performHLD(int root) {
  dfs(root, 0);
  chainCnt = 0;
  flatCnt = 0;
  chainHead[0] = root;
  HLD(root, 0);
}
vector<long long> girls[MAXN];
int tym;
int shuru[MAXN], shesh[MAXN];
void dfs2(int u, int p) {
  shuru[u] = ++tym;
  for (int v : edg[u]) {
    if (v == p) continue;
    dfs2(v, u);
  }
  shesh[u] = ++tym;
}
struct BIT {
  long long a[MAXN];
  void update(int idx, long long v) {
    if (idx == 0) return;
    while (idx < MAXN) {
      a[idx] += v;
      idx += idx & (-idx);
    }
  }
  long long query(int idx) {
    long long ans = 0;
    while (idx > 0) {
      ans += a[idx];
      idx -= idx & (-idx);
    }
    return ans;
  }
} fenwick;
pair<long long, long long> tr[4 * MAXN];
long long lazy[4 * MAXN];
void build(int u, int l, int r) {
  if (l == r) {
    tr[u].first = girls[flat[l]].back();
    tr[u].second = flat[l];
    return;
  }
  int mid = (l + r) / 2;
  build(u * 2, l, mid);
  build(u * 2 + 1, mid + 1, r);
  tr[u] = min(tr[u * 2], tr[u * 2 + 1]);
}
void propagate(int u, int l, int r) {
  if (lazy[u]) {
    tr[u].first += lazy[u];
    if (l != r) {
      lazy[u * 2] += lazy[u];
      lazy[u * 2 + 1] += lazy[u];
    }
    lazy[u] = 0;
  }
}
void update(int u, int l, int r, int x, int y, long long v) {
  propagate(u, l, r);
  if (r < x || y < l) return;
  if (x <= l && r <= y) {
    lazy[u] += v;
    propagate(u, l, r);
    return;
  }
  int mid = (l + r) / 2;
  update(u * 2, l, mid, x, y, v);
  update(u * 2 + 1, mid + 1, r, x, y, v);
  tr[u] = min(tr[u * 2], tr[u * 2 + 1]);
}
pair<long long, long long> query(int u, int l, int r, int x, int y) {
  propagate(u, l, r);
  if (x <= l && r <= y) return tr[u];
  int mid = (l + r) / 2;
  if (y <= mid) return query(u * 2, l, mid, x, y);
  if (mid < x) return query(u * 2 + 1, mid + 1, r, x, y);
  return min(query(u * 2, l, mid, x, y), query(u * 2 + 1, mid + 1, r, x, y));
}
int n;
void updateSubtree(int u, long long k) {
  fenwick.update(shuru[u], k);
  fenwick.update(shesh[u], -k);
  update(1, 0, n - 1, flatIdx[u], flatIdx[chainTail[chainIdx[u]]], k);
}
void upSegments(int l, int u, pair<long long, long long> &rt) {
  vector<pair<int, int> > vp;
  while (chainIdx[l] != chainIdx[u]) {
    int uhead = chainHead[chainIdx[u]];
    vp.push_back(pair<int, int>(flatIdx[uhead], flatIdx[u]));
    u = pr[uhead][0];
  }
  if (l != u) {
    vp.push_back(pair<int, int>(flatIdx[l] + 1, flatIdx[u]));
  }
  reverse(vp.begin(), vp.end());
  for (pair<int, int> p : vp) {
    int c = chainIdx[flat[p.first]];
    long long upore = fenwick.query(shuru[chainHead[c]] - 1);
    pair<long long, long long> q = query(1, 0, n - 1, p.first, p.second);
    q.first += upore;
    rt = min(rt, q);
  }
}
int findPretty(int u, int v) {
  int l = getLCA(u, v);
  long long sobaiPabe = fenwick.query(shuru[l]);
  pair<long long, long long> rt(sobaiPabe + girls[l].back(), l);
  upSegments(l, u, rt);
  upSegments(l, v, rt);
  if (rt.first < INF) return rt.second;
  return -1;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int m, q;
  cin >> n >> m >> q;
  for (int i = 1; i < n; i++) {
    int u, v;
    cin >> u >> v;
    edg[u].push_back(v);
    edg[v].push_back(u);
  }
  performHLD(1);
  dfs2(1, 0);
  for (int i = 1; i <= m; i++) {
    int u;
    cin >> u;
    girls[u].push_back(i);
  }
  for (int i = 1; i <= n; i++) {
    girls[i].push_back(INF + i);
    reverse(girls[i].begin(), girls[i].end());
  }
  build(1, 0, n - 1);
  while (q--) {
    int t;
    cin >> t;
    if (t == 2) {
      int v, k;
      cin >> v >> k;
      updateSubtree(v, k);
    } else {
      int u, v, k;
      cin >> u >> v >> k;
      vector<int> invited;
      while (k--) {
        int x = findPretty(u, v);
        if (x == -1) break;
        invited.push_back(girls[x].back());
        long long wt = girls[x].back();
        girls[x].pop_back();
        assert(!girls[x].empty());
        wt = girls[x].back() - wt;
        update(1, 0, n - 1, flatIdx[x], flatIdx[x], wt);
      }
      cout << invited.size();
      for (int x : invited) cout << " " << x;
      cout << "\n";
    }
  }
  return 0;
}
