BOI 2017 - rai

// https://qoj.ac/problem/31

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

constexpr int sizik = 100 * 1001;
constexpr int sizik2 = 20;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;

int val[sizik], parent[sizik];
int up[sizik][sizik2];
int pre[sizik], post[sizik], timer = 1;
int depth[sizik];
int dp[sizik];

std::vector<int> kra[sizik];

void dfs(int v, int p, int d) {
    pre[v] = timer++;
    parent[v] = p;
    depth[v] = d;
    up[v][0] = p;
    for (int i = 1; i < sizik2; i++) {
        up[v][i] = up[up[v][i - 1]][i - 1];
    }

    for (const auto& u : kra[v]) {
        if (u == p) continue;
        dfs(u, v, d + 1);
    }

    post[v] = timer++;
}

bool is_ancestor(int a, int b) {
    return pre[a] <= pre[b] && post[a] >= post[b];
}

int lca(int a, int b) {
    if (is_ancestor(a, b)) return a;
    if (is_ancestor(b, a)) return b;

    for (int i = sizik2 - 1; i >= 0; i--) {
        if (!is_ancestor(up[a][i], b)) a = up[a][i];
    }

    return up[a][0];
}

void add_path(int a, int b) {
    int c = lca(a, b);
    val[a]++;
    val[b]++;
    val[c] -= 2;
}

void calc_dp(int v, int p) {
    dp[v] = val[v];
    for (const auto& u : kra[v]) {
        if (u == p) continue;
        calc_dp(u, v);
        dp[v] += dp[u];
    }
}

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;

    std::map<int, int> kra_id;
    std::vector<std::pair<int, int>> kraw(n);

    for (int i = 0; i < n - 1; i++) {
        int a, b;
        std::cin >> a >> b;

        kra[a].push_back(b);
        kra[b].push_back(a);
        kraw[i] = {a, b};
    }

    dfs(1, 1, 1);

    for (int i = 0; i < n - 1; i++) {
        auto [a, b] = kraw[i];
        if (parent[a] == b) std::swap(a, b);
        kra_id[b] = i + 1;
    }

    for (int i = 1; i <= m; i++) {
        int s;
        std::cin >> s;

        std::vector<int> v(s);
        for (auto& a : v) {
            std::cin >> a;
        }
        std::sort(v.begin(), v.end(), [](int a, int b) { return pre[a] < pre[b]; });
        for (int i = 1; i < s; i++) {
            add_path(v[i - 1], v[i]);
        }
        add_path(v[s - 1], v[0]);
    }

    calc_dp(1, 1);

    std::vector<int> ans;
    ans.reserve(n);
    for (int i = 2; i <= n; i++) {
        if (dp[i] >= 2 * k) {
            ans.push_back(kra_id[i]);
        }
    }

    std::cout << ans.size() << '\n';
    std::sort(ans.begin(), ans.end());
    for (const auto& x : ans) {
        std::cout << x << " ";
    }
    std::cout << '\n';
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}