#include <bits/stdc++.h>

struct HLD {
  const std::vector<std::vector<std::pair<int, int>>>& adj;
  std::vector<int> dep, tl, tr, par, pid, sub;
  std::vector<int> root, cha, ind;
  std::vector<std::vector<int>> diff;
  void dfs(int node, int& cnt, std::vector<int>& hc) {
    tl[node] = cnt++;
    for (auto [id, i] : adj[node]) {
      if (i == par[node]) {
        continue;
      }
      dep[i] = dep[node] + 1;
      par[i] = node;
      pid[i] = id;
      dfs(i, cnt, hc);
      sub[node] += sub[i];
    }
    tr[node] = cnt - 1;
    for (auto [id, i] : adj[node]) {
      if (i == par[node]) {
        continue;
      }
      if (hc[node] == -1 || sub[hc[node]] < sub[i]) {
        hc[node] = i;
      }
    }
  }
  explicit HLD(const std::vector<std::vector<std::pair<int, int>>>& adj_)
    : adj(adj_), dep(adj.size()), tl(adj.size()), tr(adj.size()),
    par(adj.size(), -1), pid(adj.size(), -1),
    sub(adj.size(), 1), root(adj.size()), cha(adj.size()), ind(adj.size())
  {
    std::vector<int> hc(adj.size(), -1);
    int cnt = 0;
    dfs(0, cnt, hc);
    cnt = 0;
    for (int i = 0; i < (int)adj.size(); ++i) {
      if (par[i] == -1 || hc[par[i]] != i) {
        cha[i] = cnt++;
        int node = i;
        int cnt2 = 0;
        while (node != -1) {
          root[node] = i;
          cha[node] = cha[i];
          ind[node] = cnt2++;
          node = hc[node];
        }
        diff.push_back(std::vector<int>(cnt2 + 1));
      }
    }
  }
  int lca(int a, int b) {
    for (; root[a] != root[b]; b = par[root[b]]) {
      if (dep[root[a]] > dep[root[b]]) {
        std::swap(a, b);
      }
    }
    if (dep[a] > dep[b]) {
      std::swap(a, b);
    }
    return a;
  }
  void add(int a, int b) {
    for (; root[a] != root[b]; b = par[root[b]]) {
      ++diff[cha[root[b]]][ind[root[b]]];
      --diff[cha[b]][ind[b] + 1];
    }
    ++diff[cha[a]][ind[a] + 1];
    --diff[cha[b]][ind[b] + 1];
  }
  int get(int node) {
    return diff[cha[node]][ind[node]];
  }
};

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int n, m, k;
  std::cin >> n >> m >> k;

  std::vector<std::vector<std::pair<int, int>>> adj(n);
  for (int i = 0; i < n - 1; ++i) {
    int a, b;
    std::cin >> a >> b;
    --a;
    --b;
    adj[a].emplace_back(i, b);
    adj[b].emplace_back(i, a);
  }

  HLD hld(adj);
  for (int t = 0; t < m; ++t) {
    int s;
    std::cin >> s;
    std::vector<int> a(s);
    for (int& v : a) {
      std::cin >> v;
      --v;
    }
    std::sort(a.begin(), a.end(), [&](int u, int v) {
      return hld.tl[u] < hld.tl[v];
    });
    int sz = (int)a.size();
    a.push_back(hld.lca(a[0], a.back()));
    for (int i = 0; i < sz - 1; ++i) {
      a.push_back(hld.lca(a[i], a[i + 1]));
    }
    std::sort(a.begin(), a.end(), [&](int u, int v) {
      return hld.tl[u] < hld.tl[v];
    });
    a.erase(std::unique(a.begin(), a.end()), a.end());
    std::stack<int> st;
    for (int i : a) {
      while (!st.empty() && hld.tr[st.top()] < hld.tl[i]) {
        st.pop();
      }
      if (!st.empty()) {
        hld.add(st.top(), i);
      }
      st.push(i);
    }
  }
  for (std::vector<int>& arr : hld.diff) {
    std::partial_sum(arr.begin(), arr.end(), arr.begin());
  }

  std::vector<int> ans;
  for (int i = 1; i < n; ++i) {
    if (hld.get(i) >= k) {
      ans.push_back(hld.pid[i]);
    }
  }

  std::cout << ans.size() << '\n';
  for (int id : ans) {
    std::cout << id + 1 << ' ';
  }
  std::cout << '\n';
}