// Problem: P8205 [Ynoi2005] vti
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P8205
// Memory Limit: 512 MB
// Time Limit: 1500 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<int, int> pii;

namespace IO {
	const int maxn = 1 << 20;
	
    char ibuf[maxn], *iS, *iT, obuf[maxn], *oS = obuf;

	inline char gc() {
		return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, maxn, stdin), (iS == iT ? EOF : *iS++) : *iS++);
	}

	template<typename T = int>
	inline T read() {
		char c = gc();
		T x = 0;
		bool f = 0;
		while (c < '0' || c > '9') {
			f |= (c == '-');
			c = gc();
		}
		while (c >= '0' && c <= '9') {
			x = (x << 1) + (x << 3) + (c ^ 48);
			c = gc();
		}
		return f ? ~(x - 1) : x;
	}

	inline void flush() {
		fwrite(obuf, 1, oS - obuf, stdout);
		oS = obuf;
	}
	
	struct Flusher {
		~Flusher() {
			flush();
		}
	} AutoFlush;

	inline void pc(char ch) {
		if (oS == obuf + maxn) {
			flush();
		}
		*oS++ = ch;
	}

	template<typename T>
	inline void write(T x) {
		static char stk[64], *tp = stk;
		if (x < 0) {
			x = ~(x - 1);
			pc('-');
		}
		do {
			*tp++ = x % 10;
			x /= 10;
		} while (x);
		while (tp != stk) {
			pc((*--tp) | 48);
		}
	}
	
	template<typename T>
	inline void writesp(T x) {
		write(x);
		pc(' ');
	}
	
	template<typename T>
	inline void writeln(T x) {
		write(x);
		pc('\n');
	}
}

using IO::read;
using IO::write;
using IO::pc;
using IO::writesp;
using IO::writeln;

const int maxn = 2000100;
const int logn = 20;

int n, m, a[maxn], dfn[maxn], tim, st[logn][maxn / 20];
ll ans[maxn];

inline int get(int i, int j) {
	return dfn[i] < dfn[j] ? i : j;
}

inline int qlca(int x, int y) {
	if (x == y) {
		return x;
	}
	x = dfn[x];
	y = dfn[y];
	if (x > y) {
		swap(x, y);
	}
	++x;
	int k = __lg(y - x + 1);
	return get(st[k][x], st[k][y - (1 << k) + 1]);
}

struct graph {
	int hd[maxn], len, to[maxn], nxt[maxn];
	
	inline void add_edge(int u, int v) {
		to[++len] = v;
		nxt[len] = hd[u];
		hd[u] = len;
	}
} G;

int tot, in[maxn];
pii ord[maxn];

void dfs(int u, int t) {
	dfn[u] = ++tim;
	st[0][tim] = t;
	if (u > 1) {
		ord[++tot] = mkp(a[u], 1);
		in[u] = tot;
	}
	for (int i = G.hd[u]; i; i = G.nxt[i]) {
		int v = G.to[i];
		if (v == t) {
			continue;
		}
		dfs(v, u);
	}
	if (u > 1) {
		ord[++tot] = mkp(a[u], -1);
	}
}

int b[maxn], K, c[maxn], tq, bel[maxn], blo;

struct que {
	int l, r, o, i;
	ll ans;
	que(int a = 0, int b = 0, int c = 0, int d = 0, ll e = 0) : l(a), r(b), o(c), i(d), ans(e) {}
} qq[maxn];

namespace BIT {
	int c[maxn];
	
	inline void update(int x, int d) {
		for (int i = x; i <= n; i += (i & (-i))) {
			c[i] += d;
		}
	}
	
	inline int query(int x) {
		int res = 0;
		for (int i = x; i; i -= (i & (-i))) {
			res += c[i];
		}
		return res;
	}
}

ll f[maxn], g[maxn];

struct line {
	int l, r, o, i;
	line(int a = 0, int b = 0, int c = 0, int d = 0) : l(a), r(b), o(c), i(d) {}
};

struct List {
	int hd[maxn], len, nxt[maxn];
	line to[maxn];
	
	inline void add(int x, line y) {
		to[++len] = y;
		nxt[len] = hd[x];
		hd[x] = len;
	}
} L1, L2;

namespace DS {
	int bel[maxn], blo, L[maxn], R[maxn], a[maxn], b[maxn];
	
	inline void init() {
		blo = sqrt(n);
		for (int i = 1; i <= n; ++i) {
			bel[i] = (i - 1) / blo + 1;
			if (!L[bel[i]]) {
				L[bel[i]] = i;
			}
			R[bel[i]] = i;
		}
	}
	
	inline void update(int x, int y) {
		for (int i = x; i <= R[bel[x]]; ++i) {
			a[i] += y;
		}
		for (int i = bel[x] + 1; i <= bel[n]; ++i) {
			b[i] += y;
		}
	}
	
	inline int query(int x) {
		return a[x] + b[bel[x]];
	}
}

void solve() {
	n = read();
	for (int i = 2; i <= n; ++i) {
		int p = read();
		a[i] = read();
		G.add_edge(p, i);
	}
	dfs(1, 0);
	for (int j = 1; (1 << j) <= n; ++j) {
		for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
			st[j][i] = get(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]);
		}
	}
	m = read();
	for (int i = 1; i <= m; ++i) {
		K = read();
		for (int j = 1; j <= K; ++j) {
			b[j] = read();
		}
		if (K == 1) {
			continue;
		}
		sort(b + 1, b + K + 1, [&](const int &x, const int &y) {
			return dfn[x] < dfn[y];
		});
		int t = K;
		for (int j = 1; j < t; ++j) {
			b[++K] = qlca(b[j], b[j + 1]);
		}
		sort(b + 1, b + K + 1, [&](const int &x, const int &y) {
			return dfn[x] < dfn[y];
		});
		K = unique(b + 1, b + K + 1) - b - 1;
		for (int j = 1; j <= K; ++j) {
			c[b[j]] = 0;
		}
		for (int j = 1; j < K; ++j) {
			int u = qlca(b[j], b[j + 1]);
			++c[u];
		}
		for (int j = 2; j <= K; ++j) {
			qq[++tq] = que(in[b[1]] + 1, in[b[j]], 1 - c[b[j]], i);
		}
	}
	blo = ceil(tot / sqrt(tq));
	for (int i = 1; i <= tot; ++i) {
		bel[i] = (i - 1) / blo + 1;
	}
	sort(qq + 1, qq + tq + 1, [&](const que &a, const que &b) {
		if (bel[a.l] != bel[b.l]) {
			return bel[a.l] < bel[b.l];
		} else if (bel[a.l] & 1) {
			return a.r < b.r; 
		} else {
			return a.r > b.r;
		}
	});
	for (int i = 1; i <= tot; ++i) {
		f[i] = f[i - 1] + BIT::query(ord[i].fst - 1) * ord[i].scd;
		g[i] = g[i - 1] + (i - 1 - BIT::query(ord[i].fst)) * ord[i].scd;
		BIT::update(ord[i].fst, ord[i].scd);
	}
	int l = 1, r = 0;
	for (int i = 1; i <= tq; ++i) {
		int ql = qq[i].l, qr = qq[i].r;
		if (l > ql) {
			qq[i].ans -= g[l - 1] - g[ql - 1];
			L2.add(r, line(ql, l - 1, 1, i));
			l = ql;
		}
		if (r < qr) {
			qq[i].ans += f[qr] - f[r];
			L1.add(l - 1, line(r + 1, qr, -1, i));
			r = qr;
		}
		if (l < ql) {
			qq[i].ans += g[ql - 1] - g[l - 1];
			L2.add(r, line(l, ql - 1, -1, i));
			l = ql;
		}
		if (r > qr) {
			qq[i].ans -= f[r] - f[qr];
			L1.add(l - 1, line(qr + 1, r, 1, i));
			r = qr;
		}
	}
	DS::init();
	for (int i = 1; i <= tot; ++i) {
		DS::update(ord[i].fst, ord[i].scd);
		for (int _ = L1.hd[i]; _; _ = L1.nxt[_]) {
			line u = L1.to[_];
			for (int j = u.l; j <= u.r; ++j) {
				qq[u.i].ans += u.o * ord[j].scd * DS::query(ord[j].fst - 1);
			}
		}
		for (int _ = L2.hd[i]; _; _ = L2.nxt[_]) {
			line u = L2.to[_];
			for (int j = u.l; j <= u.r; ++j) {
				qq[u.i].ans += u.o * ord[j].scd * (i - DS::query(ord[j].fst));
			}
		}
	}
	for (int i = 1; i <= tq; ++i) {
		qq[i].ans += qq[i - 1].ans;
		ans[qq[i].i] += qq[i].ans * qq[i].o;
	}
	for (int i = 1; i <= m; ++i) {
		writeln(ans[i]);
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}