#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 100000ll * 100000ll * 100000ll;
vector<deque<long long>> girls;
class streew {
 public:
  std::vector<long long> t;
  int s;
  void build(std::vector<int>& a, int v, int tl, int tr) {
    if (v == 1) {
      t.resize(a.size() * 4);
      s = a.size();
    }
    if (tl == tr) {
      t[v] = a[tl];
    } else {
      int tm = (tl + tr) / 2;
      build(a, v * 2, tl, tm);
      build(a, v * 2 + 1, tm + 1, tr);
    }
  }
  void update(int v, int tl, int tr, int l, int r, long long add) {
    if (l > r) return;
    if (l == tl && tr == r)
      t[v] += add;
    else {
      int tm = (tl + tr) / 2;
      update(v * 2, tl, tm, l, min(r, tm), add);
      update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, add);
    }
  }
  long long get(int v, int tl, int tr, int pos) {
    if (tl == tr) return t[v];
    int tm = (tl + tr) / 2;
    if (pos <= tm)
      return t[v] + get(v * 2, tl, tm, pos);
    else
      return t[v] + get(v * 2 + 1, tm + 1, tr, pos);
  }
};
class streemin {
 public:
  vector<pair<long long, int>> t;
  std::vector<long long> tmod;
  int s;
  void build(std::vector<int>& a, int v, int tl, int tr) {
    if (v == 1) {
      t.resize(a.size() * 4);
      tmod.resize(a.size() * 4);
      s = a.size();
    }
    if (tl == tr) {
      t[v] = make_pair(girls[a[tl]].front(), a[tl]);
      tmod[v] = 0;
    } else {
      int tm = (tl + tr) / 2;
      build(a, v * 2, tl, tm);
      build(a, v * 2 + 1, tm + 1, tr);
      t[v] = min(t[v * 2], t[v * 2 + 1]);
      tmod[v] = 0;
    }
  }
  void update(int v, int tl, int tr, int l, int r, long long add) {
    if (l > r) return;
    if (l == tl && tr == r) {
      tmod[v] += add;
    } else {
      int tm = (tl + tr) / 2;
      update(v * 2, tl, tm, l, min(r, tm), add);
      update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, add);
      pair<long long, int> tv2(t[v * 2]);
      tv2.first += tmod[v * 2];
      pair<long long, int> tv21(t[v * 2 + 1]);
      tv21.first += tmod[v * 2 + 1];
      t[v] = min(tv2, tv21);
    }
  }
  pair<long long, int> get(int v, int tl, int tr, int l, int r) {
    if (l > r) {
      return make_pair(INF, -1);
    }
    if (l == tl && tr == r) {
      auto res = t[v];
      res.first += tmod[v];
      return res;
    }
    int tm = (tl + tr) / 2;
    auto res = min(get(v * 2, tl, tm, l, min(r, tm)),
                   get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
    res.first += tmod[v];
    return res;
  }
};
vector<streemin> hld;
int n;
std::vector<std::vector<int>> ch, nb;
std::vector<int> par, v_lvl;
std::vector<std::vector<int>> lvl;
std::vector<int> trav;
std::vector<int> pos, rpos;
std::vector<int> st;
void bfs1(int v) {
  pos[v] = trav.size();
  trav.push_back(v);
  for (auto u : ch[v]) bfs1(u);
  rpos[v] = trav.size() - 1;
}
std::vector<std::vector<int>> path;
std::vector<std::pair<int, int>> whichpath;
void dfshld(int v, int pind) {
  if (pind == -1) {
    pind = path.size();
    path.push_back(std::vector<int>());
  }
  whichpath[v] = make_pair(pind, (int)path[pind].size());
  path[pind].push_back(v);
  for (auto u : ch[v]) {
    if (2 * st[u] >= st[v])
      dfshld(u, pind);
    else
      dfshld(u, -1);
  }
}
int main() {
  int m, q;
  scanf("%d %d %d", &n, &m, &q);
  pos.resize(n);
  rpos.resize(n);
  v_lvl.resize(n);
  whichpath.resize(n);
  par.resize(n);
  ch.resize(n);
  nb.resize(n);
  lvl.resize(n + 1);
  girls.resize(n);
  int mm = 1;
  lvl[1].push_back(0);
  v_lvl[0] = 1;
  for (int i = 1; i < n; i++) {
    int u, v;
    scanf("%d %d", &u, &v);
    u--;
    v--;
    nb[u].push_back(v);
    nb[v].push_back(u);
  }
  int l = 2;
  while (mm < n) {
    for (int k = 0; k < lvl[l - 1].size(); k++) {
      int v = lvl[l - 1][k];
      for (int h = 0; h < nb[v].size(); h++) {
        if (v_lvl[nb[v][h]] == 0) {
          v_lvl[nb[v][h]] = l;
          lvl[l].push_back(nb[v][h]);
          mm++;
          ch[v].push_back(nb[v][h]);
          par[nb[v][h]] = v;
        }
      }
    }
    l++;
  }
  l--;
  for (int i = 1; i < m + 1; i++) {
    int x;
    scanf("%d", &x);
    x--;
    girls[x].push_back(i);
  }
  for (int i = 0; i < n; i++) girls[i].push_back(INF);
  bfs1(0);
  st.resize(n);
  for (int i = 0; i < n; i++) st[i] = rpos[i] - pos[i] + 1;
  streew w;
  std::vector<int> wbase(n, 0);
  w.build(wbase, 1, 0, n - 1);
  dfshld(0, -1);
  for (auto& pt : path) {
    hld.push_back(streemin());
    hld.back().build(pt, 1, 0, (int)pt.size() - 1);
  }
  for (int i = 0; i < q; i++) {
    int tp;
    scanf("%d", &tp);
    if (tp == 2) {
      int v;
      int kk;
      scanf("%d %d", &v, &kk);
      v--;
      long long k = kk;
      w.update(1, 0, n - 1, pos[v], rpos[v], k);
      std::pair<int, int> pt = whichpath[v];
      hld[pt.first].update(1, 0, (int)path[pt.first].size() - 1, pt.second,
                           (int)path[pt.first].size() - 1, k);
    } else if (tp == 1) {
      int u, v, k;
      scanf("%d %d %d", &u, &v, &k);
      u--;
      v--;
      std::vector<int> ans;
      int uorig = u;
      int vorig = v;
      while (k > 0) {
        u = uorig;
        v = vorig;
        pair<long long, int> best = make_pair(INF, -1);
        while (!(pos[u] <= pos[v] && pos[v] <= rpos[u])) {
          std::pair<int, int> wp = whichpath[u];
          if (wp.second == 0) {
            best = min(
                best,
                make_pair(girls[u].front() + w.get(1, 0, n - 1, pos[u]), u));
            u = par[u];
          } else {
            int upar = path[wp.first][0];
            if (pos[upar] <= pos[v] && pos[v] <= rpos[upar]) {
              int l = 0;
              int r = wp.second;
              while (r - l > 1) {
                int med = (r + l) / 2;
                int um = path[wp.first][med];
                if (pos[um] <= pos[v] && pos[v] <= rpos[um])
                  l = med;
                else
                  r = med;
              }
              int bper =
                  hld[wp.first]
                      .get(1, 0, (int)path[wp.first].size() - 1, l, wp.second)
                      .second;
              if (bper != -1)
                best = min(best, make_pair(girls[bper].front() +
                                               w.get(1, 0, n - 1, pos[bper]),
                                           bper));
              u = path[wp.first][l];
            } else {
              int bper =
                  hld[wp.first]
                      .get(1, 0, (int)path[wp.first].size() - 1, 0, wp.second)
                      .second;
              if (bper != -1)
                best = min(best, make_pair(girls[bper].front() +
                                               w.get(1, 0, n - 1, pos[bper]),
                                           bper));
              u = par[upar];
            }
          }
        }
        swap(u, v);
        while (!(pos[u] <= pos[v] && pos[v] <= rpos[u])) {
          std::pair<int, int> wp = whichpath[u];
          if (wp.second == 0) {
            best = min(
                best,
                make_pair(girls[u].front() + w.get(1, 0, n - 1, pos[u]), u));
            u = par[u];
          } else {
            int upar = path[wp.first][0];
            if (pos[upar] <= pos[v] && pos[v] <= rpos[upar]) {
              int l = 0;
              int r = wp.second;
              while (r - l > 1) {
                int med = (r + l) / 2;
                int um = path[wp.first][med];
                if (pos[um] <= pos[v] && pos[v] <= rpos[um])
                  l = med;
                else
                  r = med;
              }
              int bper =
                  hld[wp.first]
                      .get(1, 0, (int)path[wp.first].size() - 1, l, wp.second)
                      .second;
              if (bper != -1)
                best = min(best, make_pair(girls[bper].front() +
                                               w.get(1, 0, n - 1, pos[bper]),
                                           bper));
              u = path[wp.first][l];
            } else {
              int bper =
                  hld[wp.first]
                      .get(1, 0, (int)path[wp.first].size() - 1, 0, wp.second)
                      .second;
              if (bper != -1)
                best = min(best, make_pair(girls[bper].front() +
                                               w.get(1, 0, n - 1, pos[bper]),
                                           bper));
              u = par[upar];
            }
          }
        }
        best = min(best,
                   make_pair(girls[u].front() + w.get(1, 0, n - 1, pos[u]), u));
        if (best.first < INF) {
          int up = best.second;
          ans.push_back(girls[up].front());
          long long fix = girls[up][1] - girls[up][0];
          girls[up].pop_front();
          std::pair<int, int> upp = whichpath[up];
          hld[upp.first].update(1, 0, (int)path[upp.first].size() - 1,
                                upp.second, upp.second, fix);
          k--;
        } else {
          break;
        }
      }
      printf("%d", ans.size());
      for (auto u : ans) printf(" %d", u);
      printf("\n");
    }
  }
}
