#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
  if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
  if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
  static char buf[buf_size];
  static int len = 0, pos = 0;
  if (pos == len) {
    pos = 0, len = fread(buf, 1, buf_size, stdin);
  }
  if (pos == len) {
    return -1;
  }
  return buf[pos++];
}
inline int readChar() {
  int c = getChar();
  while (c <= 32) {
    c = getChar();
  }
  return c;
}
template <class T>
inline T readInt() {
  int s = 1, c = readChar();
  T x = 0;
  if (c == '-') s = -1, c = getChar();
  while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
  return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
  if (write_pos == buf_size)
    fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
  write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
  if (x < 0) writeChar('-'), x = -x;
  char s[24];
  int n = 0;
  while (x || !n) s[n++] = '0' + x % 10, x /= 10;
  while (n--) writeChar(s[n]);
  if (end) writeChar(end);
}
inline void writeWord(const char *s) {
  while (*s) writeChar(*s++);
}
struct Flusher {
  ~Flusher() {
    if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
  }
} flusher;
const string FILENAME = "input";
const int MAXN = 100001;
int n;
vector<int> g[MAXN], v[MAXN];
int sz[MAXN];
int in[MAXN], out[MAXN];
int whin[MAXN];
int next228[MAXN];
int pr[MAXN];
int parent[MAXN][18];
int t = 0;
void dfs(int u) {
  for (auto h : v[u]) {
    if (h != pr[u]) {
      pr[h] = u;
      parent[h][0] = u;
      dfs(h);
      g[u].push_back(h);
    }
  }
}
void dfs_sz(int u) {
  sz[u] = 1;
  for (auto &h : g[u]) {
    dfs_sz(h);
    sz[u] += sz[h];
    if (sz[h] > sz[g[u][0]]) {
      swap(h, g[u][0]);
    }
  }
}
void dfs_hld(int u) {
  in[u] = ++t;
  whin[in[u]] = u;
  for (auto &h : g[u]) {
    next228[h] = (h == g[u][0] ? next228[u] : h);
    dfs_hld(h);
  }
  out[u] = t;
}
int m, q;
int cnt[MAXN];
int r[MAXN];
pair<long long, int> d[4 * MAXN];
long long mod[4 * MAXN];
int ss = 1;
inline void push(int v) {
  if (mod[v] != 0) {
    d[v].first += mod[v];
    if (v < ss) {
      mod[v * 2] += mod[v];
      mod[v * 2 + 1] += mod[v];
    }
    mod[v] = 0;
  }
}
void add(int v, int vl, int vr, int l, int r, long long x) {
  if (vl > r || vr < l) {
    push(v);
    return;
  }
  if (l <= vl && vr <= r) {
    mod[v] += x;
    push(v);
    return;
  }
  push(v);
  add(v * 2, vl, (vl + vr) / 2, l, r, x);
  add(v * 2 + 1, (vl + vr) / 2 + 1, vr, l, r, x);
  d[v] = min(d[v * 2], d[v * 2 + 1]);
}
pair<long long, int> rmq(int v, int vl, int vr, int l, int r) {
  if (vl > r || vr < l) {
    return make_pair((long long)1e18, -1);
  }
  if (l <= vl && vr <= r) {
    push(v);
    return d[v];
  }
  push(v);
  return min(rmq(v * 2, vl, (vl + vr) / 2, l, r),
             rmq(v * 2 + 1, (vl + vr) / 2 + 1, vr, l, r));
}
set<int> h[MAXN];
int gt[MAXN];
bool isparent(int a, int b) { return in[a] <= in[b] && out[b] <= out[a]; }
int lca(int a, int b) {
  if (isparent(a, b)) {
    return a;
  }
  if (isparent(b, a)) {
    return b;
  }
  for (int k = 17; k >= 0; k--) {
    if (!isparent(parent[a][k], b)) {
      a = parent[a][k];
    }
  }
  return parent[a][0];
}
pair<long long, int> st;
inline void checkpath(int a, int b) {
  while (true) {
    int f = next228[a];
    if (isparent(f, b)) {
      chkmin(st, rmq(1, 1, ss, in[b], in[a]));
      break;
    } else {
      chkmin(st, rmq(1, 1, ss, in[f], in[a]));
      a = pr[f];
    }
  }
}
int getBest(int a, int b) {
  if (!isparent(b, a)) {
    swap(a, b);
  }
  st = make_pair((long long)1e18, (int)1e9);
  if (!isparent(b, a)) {
    int c = lca(a, b);
    checkpath(a, c);
    checkpath(b, c);
  } else {
    checkpath(a, b);
  }
  if (st.first > (long long)1e17) {
    return -1;
  }
  int where = st.second;
  int j = in[where - 1];
  int sts = *h[where].begin();
  h[where].erase(sts);
  if (h[where].empty()) {
    add(1, 1, ss, j, j, (long long)1e18 - (long long)sts);
  } else {
    add(1, 1, ss, j, j, *h[where].begin() - sts);
  }
  return sts;
}
int main() {
  n = readInt(), m = readInt(), q = readInt();
  for (int i = 0; i < n - 1; i++) {
    int a = readInt(), b = readInt();
    a--, b--;
    v[a].push_back(b);
    v[b].push_back(a);
  }
  pr[0] = -1;
  dfs(0);
  dfs_sz(0);
  dfs_hld(0);
  for (int k = 1; k <= 17; k++) {
    for (int i = 0; i < n; i++) {
      parent[i][k] = parent[parent[i][k - 1]][k - 1];
    }
  }
  for (int i = 0; i < m; i++) {
    int pos = readInt();
    gt[i + 1] = pos;
    cnt[pos]++;
    h[pos].insert(i + 1);
  }
  ss = 1;
  while (ss <= n) {
    ss <<= 1;
  }
  for (int i = 1; i <= n; i++) {
    d[ss + i - 1] = make_pair((long long)1e18, whin[i] + 1);
  }
  for (int i = ss - 1; i >= 0; i--) {
    d[i] = min(d[i * 2], d[i * 2 + 1]);
  }
  for (int i = 1; i <= n; i++) {
    int j = whin[i] + 1;
    if (!h[j].empty()) {
      add(1, 1, ss, i, i, *h[j].begin() - (long long)1e18);
    }
  }
  for (int it = 0; it < q; it++) {
    int t = readInt();
    if (t == 1) {
      int a = readInt(), b = readInt();
      a--, b--;
      int kek = readInt();
      vector<int> tpt;
      for (int it = 0; it < kek; it++) {
        int tp = getBest(a, b);
        if (tp == -1) {
          break;
        }
        tpt.push_back(tp);
      }
      writeInt((int)(tpt).size());
      for (auto x : tpt) {
        writeChar(' ');
        writeInt(x);
      }
      writeChar('\n');
    } else {
      int vk = readInt(), num = readInt();
      vk--;
      add(1, 1, ss, in[vk], out[vk], num);
    }
  }
}
