//virtual tree

/*Huyyt*/

#include<bits/stdc++.h>

#define mem(a,b) memset(a,b,sizeof(a))

#define TS cout<<"!!!"<<endl

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const double eps = 1e-;

const int dir[][] = {{, }, {, }, {, -}, { -, }, {, }, {, -}, { -, -}, { -, }};

const int mod = 1e9 + , gakki =  +  +  +  + 1e9;

const int MAXN = 3e5 + , MAXM = 3e5 + , MAXQ = , INF = 1e9;

const ll LLINF = (1LL << );

int to[MAXM << ], nxt[MAXM << ], Head[MAXN], tot = ;

inline void addedge(int u, int v) {

        if (u == v) {

                return ;

        }

        to[++tot] = v;

        nxt[tot] = Head[u];

        Head[u] = tot;

}

template <typename T> inline void read(T&x) {

        char cu = getchar();

        x = ;

        bool fla = ;

        while (!isdigit(cu)) {

                if (cu == '-') {

                        fla = ;

                }

                cu = getchar();

        }

        while (isdigit(cu)) {

                x = x *  + cu - '', cu = getchar();

        }

        if (fla) {

                x = -x;

        }

}

int n;

int jumpfa[MAXN][];

int sz[MAXN];

int dfn[MAXN], deep[MAXN];

int cnt = ;

int top;

int s[MAXN];

int k[MAXN], k2[MAXN];

bool del[MAXN];

void dfs1(int x, int fa) {

        jumpfa[x][] = fa;

        dfn[x] = ++cnt;

        sz[x] = ;

        for (int i = ; i <= ; i++) {

                jumpfa[x][i] = jumpfa[jumpfa[x][i - ]][i - ];

        }

        for (int v, i = Head[x]; i; i = nxt[i]) {

                if (v = to[i], v != fa) {

                        deep[v] = deep[x] + ;

                        dfs1(v, x);

                        sz[x] += sz[v];

                }

        }

}

inline int lca(int x, int y) {

        if (deep[x] < deep[y]) {

                swap(x, y);

        }

        int t = ;

        while (( << t) <= deep[x]) {

                t++;

        }

        t--;

        for (int i = t; i >= ; i--) {

                if (deep[x] - ( << i) >= deep[y]) {

                        x = jumpfa[x][i];

                }

        }

        if (x == y) {

                return x;

        }

        for (int i = t; i >= ; i--) {

                if (jumpfa[x][i] != jumpfa[y][i]) {

                        x = jumpfa[x][i], y = jumpfa[y][i];

                }

        }

        return jumpfa[x][];

}

inline bool cmp(int a, int b) {

        return dfn[a] < dfn[b];

}

inline void insert_point(int x) {

        if (top == ) {

                s[++top] = x;

                return ;

        }

        int grand = lca(x, s[top]);

        if (grand == s[top]) {

                s[++top] = x;

                return ;

        }

        while (top >=  && dfn[s[top - ]] >= dfn[grand]) {

                addedge(s[top - ], s[top]);

                top--;

        }

        if (grand != s[top]) {

                addedge(grand, s[top]);

                s[top] = grand;

        }

        s[++top] = x;

}

int getpoint(int x, int depcha) {

        int aim = x;

        for (int i = ; i >= ; i--) {

                if (( << i) <= depcha) {

                        depcha -= ( << i);

                        aim = jumpfa[aim][i];

                }

        }

        return aim;

}

int getdis(int x, int y) {

        return deep[x] + deep[y] -  * deep[lca(x, y)];

}

int belong[MAXN];

int ans[MAXN], rest[MAXN];

void getbelong1(int x, int fa) {

        rest[x] = sz[x];

        for (int i = Head[x]; i; i = nxt[i]) {

                int v = to[i];

                if (v == fa) {

                        continue;

                }

                int aim;

                aim = getpoint(v, deep[v] - deep[x] - );

                rest[x] -= sz[aim];

                getbelong1(v, x);

                if (belong[v] == ) {

                        continue;

                }

                if (belong[x] == ) {

                        belong[x] = belong[v];

                } else {

                        int dis1, dis2;

                        dis1 = getdis(x, belong[x]), dis2 = getdis(x, belong[v]);

                        if (dis1 > dis2 || (dis1 == dis2 && belong[x] > belong[v])) {

                                belong[x] = belong[v];

                        }

                }

        }

}

void getbelong2(int x, int fa) {

        for (int i = Head[x]; i; i = nxt[i]) {

                int v = to[i];

                if (v == fa) {

                        continue;

                }

                if (belong[v] == ) {

                        belong[v] = belong[x];

                } else {

                        int dis1, dis2;

                        dis1 = getdis(v, belong[x]), dis2 = getdis(v, belong[v]);

                        if (dis1 < dis2 || (dis1 == dis2 && belong[v] > belong[x])) {

                                belong[v] = belong[x];

                        }

                }

                getbelong2(v, x);

        }

}

void getans(int x, int fa) {

        int aim, now;

        ans[belong[x]] += rest[x];

        for (int i = Head[x]; i; i = nxt[i]) {

                int v = to[i];

                if (v == fa) {

                        continue;

                }

                getans(v, x);

                if (deep[v] - deep[x] == ) {

                        continue;

                }

                if (belong[x] == belong[v]) {

                        aim = getpoint(v, deep[v] - deep[x] - );

                        ans[belong[x]] += sz[aim] - sz[v];

                } else {

                        now = v;

                        for (int i = ; i >= ; i--) {

                                aim = jumpfa[now][i];

                                if (deep[aim] <= deep[x]) {

                                        continue;

                                }

                                int dis1, dis2;

                                dis1 = getdis(aim, belong[x]), dis2 = getdis(aim, belong[v]);

                                if (dis1 > dis2 || (dis1 == dis2 && belong[x] > belong[v])) {

                                        now = aim;

                                }

                        }

                        aim = getpoint(v, deep[v] - deep[x] - );

                        ans[belong[x]] += sz[aim] - sz[now];

                        ans[belong[v]] += sz[now] - sz[v];

                }

        }

}

void init(int x, int fa) {

        for (int i = Head[x]; i; i = nxt[i]) {

                int v = to[i];

                if (v == fa) {

                        continue;

                }

                init(v, x);

        }

        Head[x] = belong[x] = ;

}

int main() {

        int u, v;

        read(n);

        for (int i = ; i <= n - ; i++) {

                read(u), read(v);

                addedge(u, v);

                addedge(v, u);

        }

        deep[] = ;

        dfs1(, );

        mem(Head, );

        int m, number, xxx;

        read(m);

        while (m--) {

                tot = ;

                top = ;

                read(number);

                xxx = number;

                for (int i = ; i <= number; i++) {

                        read(k[i]);

                        k2[i] = k[i];

                        del[k[i]] = ;

                        belong[k[i]] = k[i];

                }

                if (belong[] == ) {

                        k[++number] = ;

                }

                sort(k + , k + number + , cmp);

                for (int i = ; i <= number; i++) {

                        insert_point(k[i]);

                }

                while (top > ) {

                        addedge(s[top - ], s[top]);

                        top--;

                }

                getbelong1(, );

                getbelong2(, );

                //                for (int i = 1; i <= n; i++) {

                //                        cout << rest[i] << " ";

                //                }

                //                cout << endl;

                //                for (int i = 1; i <= n; i++) {

                //                        cout << belong[i] << " ";

                //                }

                //                cout << endl;

                getans(, );

                printf("%d", ans[k2[]]);

                for (int i = ; i <= xxx; i++) {

                        printf(" %d", ans[k2[i]]);

                }

                puts("");

                init(, );

                for (int i = ; i <= number; i++) {

                        del[k[i]] = ;

                        ans[k[i]] = ;

                }

        }

        return ;

}