#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

typedef pair<int,int> PII;

const int INF = 0x7f7f7f7f;
const int N = 500005<<1;

struct SegTree {
	struct Node {
		int l, r, ma, dirty;
		Node() : ma(0), dirty(0) {}
		void update(int val) {
			ma = max(ma, val);
			dirty = max(dirty, val);
		}
		int mm() { return (l+r)>>1; }
	} v[N<<2];
	int ll(int x) { return x<<1; }
	int rr(int x) { return x<<1|1; }
	void build(int l, int r, int x = 1) {
		v[x].l = l, v[x].r = r;
		if(l+1 == r) return ;
		int m = (l+r)>>1;
		build(l, m, ll(x));
		build(m, r, rr(x));
	}
	void push_down(int x) {
		if(!v[x].dirty) return ;
		v[ll(x)].update(v[x].dirty);
		v[rr(x)].update(v[x].dirty);
		v[x].dirty = 0;
	}
	void update(int l, int r, int val, int x = 1) {
		if(l <= v[x].l && v[x].r <= r) {
			v[x].update(val);
			return ;
		}
		int m = v[x].mm();
		if(v[x].l != m) push_down(x);
		if(l < m) update(l, r, val, ll(x));
		if(m < r) update(l, r, val, rr(x));
		v[x].ma = max(v[ll(x)].ma, v[rr(x)].ma);
	}
	int query(int idx, int x = 1) {
		int m = v[x].mm();
		if(v[x].l == m) return v[x].ma;
		push_down(x);
		return query(idx, idx < m ? ll(x) : rr(x));
	}
} tr;

int n = 500000;
int m, Q, fa[N], ft[N], ind[N], mp[N], L[N], R[N], time, ans[N];
bool vst[N];
vector<PII> query[N];
vector<int> e[N];

bool cmp(const int& a, const int& b) { return L[a] < L[b]; }

void dfs(int x) {
	L[x] = time++;
	for(size_t i = 0; i < e[x].size(); ++i) dfs(e[x][i]);
	R[x] = time;
}

void gao(int x) {
	for(size_t i = 0; i < e[x].size(); ++i) gao(e[x][i]);
	for(size_t i = 0; i < query[x].size(); ++i) {
		int fid = query[x][i].first;
		int qid = query[x][i].second;
		ans[qid] = min(ans[qid], tr.query(L[fid]));
	}
	tr.update(L[x], R[x], ft[x]);
}

int main() {
	scanf("%d", &m);
	for(int a, b, i = 1; i <= m; ++i) {
		scanf("%d%d", &a, &b);
		fa[b] = a, ft[b] = i, ++ind[a];
	}
	queue<int> q;
	for(int i = 1; i <= n; ++i)
		if(!ind[i]) q.push(i);
	while(!q.empty()) {
		int x = q.front(); q.pop();
		vst[x] = true;
		if(fa[x]) {
			if(!--ind[fa[x]]) q.push(fa[x]);
		}
	}
	for(int i = n; i >= 1; --i) {
		if(!vst[i]) {
			vector<int> v;
			int x = i;
			do {
				vst[x] = true;
				v.push_back(x);
				x = fa[x];
			} while(x && x != i);
			int sz = v.size();
			
			for(int j = 0, k = v[sz-1]; j < sz; ++j, k = fa[k]) {
				mp[v[j]] = fa[k] = ++n;
				if(j) ft[k] = ft[v[j-1]];
			}
		}
	}
	for(int i = 1; i <= n; ++i) e[fa[i]].push_back(i);
	dfs(0);
	scanf("%d", &Q);
	for(int tn, fn, i = 0; i < Q; ++i) {
		vector<int> t, f;
		scanf("%d", &tn);
		for(int x, j = 0; j < tn; ++j) {
			scanf("%d", &x);
			t.push_back(x);
			if(mp[x]) t.push_back(mp[x]);
		}
		tn = t.size();
		scanf("%d", &fn);
		for(int x, j = 0; j < fn; ++j) {
			scanf("%d", &x);
			f.push_back(x);
		}
		sort(t.begin(), t.end(), cmp);
		sort(f.begin(), f.end(), cmp);
		vector<int> v;
		for(int j = 0, k = 0; j < fn; ++j) {
			for(; k < tn && L[t[k]] < L[f[j]]; ++k) v.push_back(t[k]);
			while(!v.empty() && R[v.back()] <= L[f[j]]) v.pop_back();
			if(!v.empty()) query[v.back()].push_back(PII(f[j], i));
		}
	}
	memset(ans, 0x7f, sizeof(ans));
	tr.build(0, n+1);
	gao(0);
	for(int i = 0; i < Q; ++i)
		printf("%d\n", ans[i]==INF?-1:ans[i]);
}