#include <bits/stdc++.h>
using namespace std;
const int nx[8] = {2, -2, -2, 2, 1, 1, -1, -1};
const int ny[8] = {1, 1, -1, -1, 2, -2, -2, 2};
const int Nx[4] = {0, 0, -1, 1};
const int Ny[4] = {1, -1, 0, 0};
const long long LINF = (long long)1e15;
const int INF = 1e9 + 7;
const int MAGIC = 2500;
const int N = 20;
const int MAXN = 2e5 + 50;
const double EPS = 1e-9, PI = 3.14159265359;
int dp[MAXN][N], cnt[MAXN], head[MAXN], pos[MAXN], lvl[MAXN];
int arr[MAXN], tin[MAXN], tout[MAXN], belongs[MAXN];
int cur_chain, sz;
vector<int> v[MAXN], g[MAXN];
int n, m, q;
void dfs(int x, int p = -1) {
  if (p + 1) {
    dp[x][0] = p;
    for (int i = 1; i < N; i++) dp[x][i] = dp[dp[x][i - 1]][i - 1];
    lvl[x] = lvl[p] + 1;
  }
  cnt[x] = 1;
  for (auto it : v[x]) {
    if (it == p) continue;
    dfs(it, x);
    cnt[x] += cnt[it];
  }
}
int get_lca(int x, int y) {
  if (lvl[x] > lvl[y]) swap(x, y);
  int d = lvl[y] - lvl[x];
  for (int i = 0; i < N; i++) {
    if ((d >> i) & 1) {
      y = dp[y][i];
    }
  }
  if (y == x) return x;
  for (int i = N - 1; i >= 0; i--) {
    if (dp[x][i] != dp[y][i]) {
      x = dp[x][i];
      y = dp[y][i];
    }
  }
  return dp[x][0];
}
void build(int x, int p = -1) {
  if (head[cur_chain] == -1) head[cur_chain] = x;
  tin[x] = tout[x] = ++sz;
  pos[x] = sz;
  arr[sz] = x;
  belongs[x] = cur_chain;
  int mx = -1;
  for (auto it : v[x]) {
    if (it == p) continue;
    if (mx == -1 || cnt[mx] < cnt[it]) mx = it;
  }
  if (mx != -1) build(mx, x);
  for (auto it : v[x]) {
    if (it == p || it == mx) continue;
    cur_chain++;
    build(it, x);
  }
  tout[x] = sz;
}
pair<long long, int> t[MAXN * 4];
long long p[MAXN * 4], t1[MAXN * 4], p1[MAXN * 4];
int ptr[MAXN];
void build_seg(int v = 1, int L = 1, int R = n) {
  if (L == R) {
    t[v].second = arr[L];
    if (g[arr[L]].empty())
      t[v].first = LINF;
    else
      t[v].first = g[arr[L]][0];
    return;
  }
  int m = (L + R) / 2;
  build_seg(v + v, L, m);
  build_seg(v + v + 1, m + 1, R);
  t[v] = min(t[v + v], t[v + v + 1]);
}
inline void push(int v, int l, int r) {
  if (p[v]) {
    t[v].first += p[v];
    if (l < r) {
      p[v + v] += p[v];
      p[v + v + 1] += p[v];
    }
    p[v] = 0;
  }
}
inline void push1(int v, int l, int r) {
  if (p1[v]) {
    t1[v] += p1[v];
    if (l < r) {
      p1[v + v] += p1[v];
      p1[v + v + 1] += p1[v];
    }
    p1[v] = 0;
  }
}
pair<long long, int> get_min(int l, int r, int v = 1, int L = 1, int R = n) {
  push(v, L, R);
  if (L > r || l > R) return make_pair(LINF, INF);
  if (l <= L && R <= r) return t[v];
  int m = (L + R) / 2;
  return min(get_min(l, r, v + v, L, m), get_min(l, r, v + v + 1, m + 1, R));
}
void update(int l, int r, long long val, int v = 1, int L = 1, int R = n) {
  push(v, L, R);
  if (L > r || l > R) return;
  if (l <= L && R <= r) {
    p[v] += val;
    push(v, L, R);
    return;
  }
  int m = (L + R) / 2;
  update(l, r, val, v + v, L, m);
  update(l, r, val, v + v + 1, m + 1, R);
  t[v] = min(t[v + v], t[v + v + 1]);
}
long long get_sum(int l, int r, int v = 1, int L = 1, int R = n) {
  push1(v, L, R);
  if (L > r || l > R) return 0;
  if (l <= L && R <= r) return t1[v];
  int m = (L + R) / 2;
  return get_sum(l, r, v + v, L, m) + get_sum(l, r, v + v + 1, m + 1, R);
}
void upd(int l, int r, long long val, int v = 1, int L = 1, int R = n) {
  push1(v, L, R);
  if (L > r || l > R) return;
  if (l <= L && R <= r) {
    p1[v] += val;
    push1(v, L, R);
    return;
  }
  int m = (L + R) / 2;
  upd(l, r, val, v + v, L, m);
  upd(l, r, val, v + v + 1, m + 1, R);
  t1[v] = t1[v + v] + t1[v + v + 1];
}
pair<long long, int> get(int x, int y) {
  pair<long long, int> ans = make_pair(LINF, INF);
  while (true) {
    int u = head[belongs[y]];
    if (belongs[y] == belongs[x]) {
      ans = min(ans, get_min(pos[x], pos[y]));
      break;
    } else {
      ans = min(ans, get_min(pos[u], pos[y]));
      y = dp[u][0];
    }
  }
  return ans;
}
long long first[MAXN];
void upd_f(int l, int val) {
  for (int i = l; i <= n; i = (i | (i + 1))) first[i] += val;
}
int main() {
  memset(head, -1, sizeof(head));
  scanf("%d%d%d", &n, &m, &q);
  for (int i = 1, x, y; i < n; i++) {
    scanf("%d%d", &x, &y);
    v[x].push_back(y);
    v[y].push_back(x);
  }
  dfs(1);
  build(1);
  for (int i = 1, x; i <= m; i++) {
    scanf("%d", &x);
    g[x].push_back(i);
  }
  build_seg();
  while (q--) {
    int type, x, y, k;
    scanf("%d", &type);
    if (type == 1) {
      scanf("%d%d%d", &x, &y, &k);
      int lca = get_lca(x, y);
      vector<int> ans;
      while (k--) {
        pair<long long, int> mx = get(lca, x);
        mx = min(mx, get(lca, y));
        if (mx.first >= LINF) break;
        ans.push_back(g[mx.second][ptr[mx.second]]);
        ptr[mx.second]++;
        update(pos[mx.second], pos[mx.second], -mx.first);
        if (ptr[mx.second] < int(g[mx.second].size())) {
          update(pos[mx.second], pos[mx.second],
                 get_sum(pos[mx.second], pos[mx.second]) +
                     g[mx.second][ptr[mx.second]]);
        } else {
          update(pos[mx.second], pos[mx.second], LINF);
        }
      }
      printf("%d ", int(ans.size()));
      for (auto it : ans) printf("%d ", it);
      puts("");
    } else {
      scanf("%d%d", &x, &k);
      update(tin[x], tout[x], k);
      upd(tin[x], tout[x], k);
    }
  }
  return 0;
}
