#include <bits/stdc++.h>
#define rep(i, l, r) for(int i = (l); i <= (r); i++)
#define per(i, r, l) for(int i = (r); i >= (l); i--)
#define mem(a, b) memset(a, b, sizeof a)
#define For(i, l, r) for(int i = (l), i##e = (r); i < i##e; i++)
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define SZ(x) int((x).size())

using namespace std;
using ll = long long;

template<class T> inline T& cmin(T& a, const T& b) { if(b < a) a = b; return a; }
template<class T> inline T& cmax(T& a, const T& b) { if(a < b) a = b; return a; }
template<class... Args> void print(Args&&... args) {
    ((cout << args << ' '), ...);
}
template<class... Args> void println(Args&&... args) {
    print(args...), cout << endl;
}

namespace ts {
    const int N = 2000 * 2000 * 4 + 8;
    const int M = 2000 * 2000 * 3 + 8;

    int eid, A[M], B[M], deg[N], G[M << 1];
    int dfc, idx, dfn[N], scc[N], tp, s[N];

    inline void add(int u, int a, int v, int b) {
        A[eid] = u * 2 + a, B[eid] = v * 2 + b;
        deg[A[eid]]++, deg[B[eid++] ^ 1]++;
    }
    int dfs(int u) {
        int low = dfn[u] = ++dfc;
        s[++tp] = u;
        For(i, deg[u], deg[u + 1]) {
            int v = G[i];
            if(!dfn[v]) cmin(low, dfs(v));
            else if(!scc[v]) cmin(low, dfn[v]);
        }
        if(low == dfn[u]) {
            idx++;
            for(int v = -1; v != u; tp--)
                v = s[tp], scc[v] = idx;
        }
        return low;
    }
    bool run(int n) {
        partial_sum(deg, deg + N, deg);
        For(i, 0, eid) {
            G[--deg[A[i]]] = B[i];
            G[--deg[B[i] ^ 1]] = A[i] ^ 1;
        }
        For(i, 0, n * 2) if(!dfn[i]) dfs(i);
        For(i, 0, n) {
            if(scc[i * 2] == scc[i * 2 + 1]) return 0;
        }
        return 1;
    }
}

const int N = 2000 + 8;

int n, m, q;
vector<int> G[N];
int dfc, fa[N], dep[N], dfn[N], seq[N], st[11][N];

void dfs(int u, int f, int d) {
    fa[u] = f, dep[u] = d;
    dfn[u] = ++dfc, seq[dfc] = u, st[0][dfc] = d - 1;
    for(int v : G[u]) if(v != f) dfs(v, u, d + 1);
}
int lca(int u, int v) {
    u = dfn[u], v = dfn[v];
    if(u > v) swap(u, v);
    int z = __builtin_ia32_bsrsi(v - u);
    return min(st[z][v], st[z][u + (1 << z)]);
}

int cnt[N][N];
vector<tuple<int, int, int>> op[N];
int x[N][N];

struct dsu {
    int fa[N];
    dsu() { mem(fa, -1); }
    int find(int x) { return fa[x] < 0 ? x : fa[x] = find(fa[x]); }
    bool merge(int u, int v) {
        u = find(u), v = find(v);
        if(u == v) return 0;
        if(fa[u] > fa[v]) swap(u, v);
        fa[u] += fa[v], fa[v] = u;
        return 1;
    }
} A[N];

int main() {
    cin.tie(0)->sync_with_stdio(0);
    cin >> n >> m >> q;
    rep(i, 2, n) {
        int u, v;
        cin >> u >> v;
        G[u].pb(v), G[v].pb(u);
    }
    dfs(1, 0, 0);
    rep(k, 0, 9) rep(i, 2 << k, n)
        st[k + 1][i] = min(st[k][i - (1 << k)], st[k][i]);
    rep(i, 1, m) {
        int c, u;
        cin >> c;
        while(c--) cin >> u, cnt[i][u]++;
        per(j, n, 1) cnt[i][fa[seq[j]]] += cnt[i][seq[j]];
    }
    while(q--) {
        int c1, c2, a[N], b[N];
        cin >> c1;
        rep(i, 1, c1) cin >> a[i];
        cin >> c2;
        rep(i, 1, c2) cin >> b[i];
        a[0] = a[c1];
        rep(i, 1, c1) {
            int d = lca(a[i - 1], a[i]);
            rep(j, 2, c2) op[d].eb(a[i], b[j - 1], b[j]);
        }
    }
    rep(i, 0, n) for(auto [u, x, y] : op[i]) {
        int len = dep[u] - i;
        while(len-- && A[u].merge(x, y)) u = fa[u];
    }
    int idx = 0;
    rep(i, 1, n) {
        rep(j, 1, m) if(A[i].fa[j] < 0) x[j][i] = idx++;
        rep(j, 1, m) x[j][i] = x[A[i].find(j)][i];
    }
    rep(i, 1, m) {
        int now[N];
        memcpy(now, x[i], sizeof now);
        per(j, n, 1) {
            int u = seq[j];
            if(!cnt[i][u]) ts::add(x[i][u], 1, x[i][u], 0);
            else if(cnt[i][u] == cnt[i][1]) ts::add(x[i][u], 0, x[i][u], 1);
            else {
                int f = fa[u];
                ts::add(x[i][u], 1, now[f], 1);
                if(dfn[f] + 1 != j) {
                    ts::add(idx, 1, now[f], 1);
                    ts::add(x[i][u], 1, idx, 0);
                    now[f] = idx++;
                }
            }
        }
    }
    if(!ts::run(idx)) cout << -1 << '\n', exit(0);
    rep(i, 1, m) {
        int res = 0;
        rep(j, 1, n) {
            int u = x[i][seq[j]];
            if(ts::scc[u * 2 + 1] < ts::scc[u * 2]) res = seq[j];
        }
        cout << res << " \n"[i == m];
    }
}