// template by paradox & gege & parasat
#include <bits/stdc++.h>                                           
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
 
using namespace std;
//using namespace __gnu_pbds;
 
//#pragma GCC optimize("Ofast")
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
 
#define file(s) freopen(s".in","r",stdin); freopen(s".out","w",stdout);
#define fastio ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define all(x) x.begin(), x.end()
#define sz(s) (int)s.size()
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define se second
#define fi first
#define s second
#define f first
 
typedef pair < int, int > pii;
typedef vector < int > vi;
typedef long double ld;
typedef long long ll;
 
//typedef tree < int, null_type, less < int >, rb_tree_tag, tree_order_statistics_node_update > ordered_set;
 
 
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1}, block = 300;
const pii base = mp(1e6 + 3, 1e6 + 7), mod = mp(1e9 + 7, 1e9 + 9);
const int inf = 1e9, MOD = 998244353;
const ll INF = 1e18;
 
const int N = 3e5;
const int M = N + 7;
const int K = 1;

vector<int> bamboo[M], edges[M];
int par[M], pos[M];

int get_par(int v) {
    return v == par[v] ? v : par[v] = get_par(par[v]);
}

void merge(int v, int u, int val) {
    v = get_par(v);
    u = get_par(u);
    if (sz(bamboo[v]) < sz(bamboo[u]))
        swap(v, u);

    for (int x : bamboo[u])
        bamboo[v].pb(x);
    edges[v].pb(val);
    for (int x : edges[u])
        edges[v].pb(x);
    par[u] = v;
}

struct segment_tree {
    static const int TN = N;
    int g[TN << 2];

    void upd(int v) {
        g[v] = max(g[v << 1], g[v << 1 | 1]);
    }
    
    void build(const vector<int> &vals, int v = 1, int tl = 1, int tr = TN) {
        if (tl == tr) {
            g[v] = tl <= sz(vals) ? vals[tl - 1] : 0;
            return;
        }
        int tm = (tl + tr) >> 1;
        build(vals, v << 1, tl, tm);
        build(vals, v << 1 | 1, tm + 1, tr);
        upd(v);
    }

    int get(int l, int r, int v = 1, int tl = 1, int tr = TN) {
        if (l > r || tl > r || l > tr)
            return 0;
        if (l <= tl && tr <= r)
            return g[v];
        int tm = (tl + tr) >> 1;
        int le = get(l, r, v << 1, tl, tm);
        int ri = get(l, r, v << 1 | 1, tm + 1, tr);
        return max(le, ri);
    }
} t;

void solve() {
	int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        par[i] = i;
        bamboo[i].pb(i);
    }

    for (int i = 1; i < n; i++) {
        int v, u;
        scanf("%d %d", &v, &u);
        merge(v, u, i);
    }

    int root = get_par(1);
    vector<int> &ord = bamboo[root];
    vector<int> &edg = edges[root];
    assert(sz(ord) == sz(edg) + 1);
    // cerr << "bamboo -> ";
    // for (int v : ord)
    //     cerr << v << " ";
    // cerr << " <-\n";
    // cerr << "edges -> ";
    // for (int x : edg) 
    //     cerr << x << " ";
    // cerr << " <-\n";
    t.build(edg);

    for (int i = 0; i < sz(ord); i++)
        pos[ord[i]] = i;

    int q;
    scanf("%d", &q);

    for (int i = 1; i <= q; i++) {
        int k;
        scanf("%d", &k);
        vector<int> ver;
        for (int j = 1; j <= k; j++) {
            int v;
            scanf("%d", &v);
            ver.pb(v);
        }
        sort(all(ver), [&](const int &v, const int &u) {
            return pos[v] < pos[u];
        });

        vector<int> vals;
        for (int i = 1; i < sz(ver); i++) {
            int l = pos[ver[i - 1]], r = pos[ver[i]];
            int val = t.get(l + 1, r);
            if (!vals.empty())
                vals.back() = min(vals.back(), val);
            else
                vals.pb(val);
            vals.pb(val);
        }

        // cerr << "r :: ";
        // for (int x : vals) 
        //     cerr << x << ' ';
        // cerr << " *\n";

        int ans = 1;
        for (int x : vals)
            ans = 1ll * ans * x % MOD;

        printf("%d\n", ans);
    }
    
}
 
int main() {
	int TT;
	TT = 1;
	// scanf("%d", &TT);
	for (int tt = 1; tt <= TT; ++tt) {
		solve();
	}
}