#include <bits/stdc++.h>

using namespace std;

const int maxn = 1e5 + 5;
const int maxm = 1e5 + 5;
const int maxq = 1e5 + 5;

int n, m, q;
int a[maxm], b[maxm], c[maxm], fa[maxm];
int px[maxn], py[maxn], pz[maxn], face[maxn];
vector<pair<int, pair<int, int> > > ed;
map<pair<int, int>, int> mp;

inline void addEdge(int p, int q, int i) {
	if (p < q) swap(p, q);
	if (mp.find(make_pair(p, q)) == mp.end()) mp[make_pair(p, q)] = i;
	else {
		int j = mp[make_pair(p, q)];
		ed.push_back(make_pair(max(pz[p], pz[q]) - 1, make_pair(i, j)));
	}
}

int h[maxq], p[maxq], ord[maxq];
long double ans[maxq];

inline int find(int u) { return (u == fa[u] ? u : (fa[u] = find(fa[u]))); }

class Data{
public:
	long double s0, s1, s2;
	Data(long double s0_ = 0, long double s1_ = 0, long double s2_ = 0): s0(s0_), s1(s1_), s2(s2_){}
	
	inline Data &operator += (const Data &oth) {
		s0 += oth.s0, s1 += oth.s1, s2 += oth.s2;
		return *this;
	}
	
	inline long double eval(long double h) {
		// printf("eval s0 = %Lf s1 = %Lf s2 = %Lf h = %Lf\n", s0, s1, s2, h);
		return s0 + s1 * h + s2 * h * h;
	}
} dat[maxm];

inline void merge(int u, int v) {
	u = find(u), v = find(v);
	if (u == v) return;
	fa[u] = v;
	dat[v] += dat[u];
	// printf("v = %d dat = %Lf %Lf %Lf\n", v, dat[v].s0, dat[v].s1, dat[v].s2);
	return;
}

vector<pair<pair<int, int>, Data> > vec;

inline long double area(long double xa, long double ya, long double za, long double xb, long double yb, long double zb, long double xc, long double yc, long double zc) {
	long double x1 = xb - xa, y1 = yb - ya, z1 = zb - za,
				x2 = xc - xa, y2 = yc - ya, z2 = zc - za;
	long double s0 = y1 * z2 - y2 * z1, s1 = z1 * x2 - x1 * z2, s2 = x1 * y2 - x2 * y1;
	return sqrt(s0 * s0 + s1 * s1 + s2 * s2) * 0.5; 
}

inline void getsep(int i) {
	// printf("getsep i = %d %d %d %d\n", i, pz[a[i]], pz[b[i]], pz[c[i]]);
	if (pz[a[i]] == pz[c[i]]) {
		long double s = area(px[a[i]], py[a[i]], pz[a[i]], px[b[i]], py[b[i]], pz[b[i]], px[c[i]], py[c[i]], pz[c[i]]);
		vec.push_back(make_pair(make_pair(pz[c[i]] - 1, i),
					Data(s, 0, 0)));	
	}
	else {
		long double r = 1.0 * (pz[b[i]] - pz[a[i]]) / (pz[c[i]] - pz[a[i]]);
		long double xm = px[c[i]] * r + px[a[i]] * (1 - r),
					ym = py[c[i]] * r + py[a[i]] * (1 - r),
					zm = pz[c[i]] * r + pz[a[i]] * (1 - r);
		if (pz[c[i]] != pz[b[i]]) {
			long double sup = area(px[c[i]], py[c[i]], pz[c[i]], xm, ym, zm, px[b[i]], py[b[i]], pz[b[i]]);
			long double s1 = sup / (pz[c[i]] - pz[b[i]]) / (pz[c[i]] - pz[b[i]]);
			// printf("sup = %Lf %d\n", sup, pz[c[i]] - pz[b[i]]);
			vec.push_back(make_pair(make_pair(pz[c[i]], i),
						Data(1.0 * pz[c[i]] * pz[c[i]] * s1, -2.0 * pz[c[i]] * s1, s1)));
			vec.push_back(make_pair(make_pair(pz[b[i]], i),
						Data(-1.0 * pz[c[i]] * pz[c[i]] * s1 + sup, 2.0 * pz[c[i]] * s1, -s1)));
		}
		if (pz[a[i]] != pz[b[i]]) {
			long double sdn = area(px[a[i]], py[a[i]], pz[a[i]], xm, ym, zm, px[b[i]], py[b[i]], pz[b[i]]);
			long double s2 = sdn / (pz[b[i]] - pz[a[i]]) / (pz[b[i]] - pz[a[i]]);
			// printf("sdn = %Lf %d\n", sdn, pz[b[i]] - pz[a[i]]);
			vec.push_back(make_pair(make_pair(pz[b[i]], i),
						Data(-1.0 * pz[a[i]] * pz[a[i]] * s2 + sdn, 2.0 * pz[a[i]] * s2, -s2)));
			vec.push_back(make_pair(make_pair(pz[a[i]], i),
						Data(1.0 * pz[a[i]] * pz[a[i]] * s2, -2.0 * pz[a[i]] * s2, s2)));
		}
	}
}

int main(){
	scanf("%d", &n);
	for (int i = 0; i < n; ++i) scanf("%d%d%d", px + i, py + i, pz + i);
	
	scanf("%d", &m);
	for (int i = 0; i < m; ++i) {
		int tmp[3]; scanf("%d%d%d", tmp + 0, tmp + 1, tmp + 2);
		--tmp[0], --tmp[1], --tmp[2];
		sort(tmp, tmp + 3, [&] (const int &p, const int &q) { return pz[p] < pz[q]; });
		a[i] = tmp[0], b[i] = tmp[1], c[i] = tmp[2];
		face[a[i]] = face[b[i]] = face[c[i]] = i;
		addEdge(a[i], b[i], i);
		addEdge(b[i], c[i], i);
		addEdge(a[i], c[i], i);
		getsep(i);
	}
	
	sort(ed.begin(), ed.end(), [&] (const pair<int, pair<int, int> > &x, const pair<int, pair<int, int> > &y) { return x.first > y.first; });
	
	scanf("%d", &q);
	
	for (int i = 0; i < q; ++i) {
		scanf("%d%d", h + i, p + i); --p[i];
		ord[i] = i;
	}
	sort(ord, ord + q, [&] (const int &i, const int &j) { return h[i] > h[j]; });
	sort(vec.begin(), vec.end(), [&] (const pair<pair<int, int>, Data> &x, const pair<pair<int, int>, Data> &y) { return x.first > y.first; });
	
	for (int i = 0; i < m; ++i) fa[i] = i;
	
	for (int it = 0, j = 0, k = 0; it < q; ++it) {
		int i = ord[it];
		// printf("query i = %d h = %d\n", i, h[i]);
		for (; j < ed.size() && ed[j].first >= h[i]; ++j) {
			// printf("  edge (%d %d)\n", ed[j].second.first, ed[j].second.second);
			merge(ed[j].second.first, ed[j].second.second);
		}
		for (; k < vec.size() && vec[k].first.first >= h[i]; ++k) {
			// printf("  area %d (%Lf %Lf %Lf)\n", vec[k].first.second, vec[k].second.s0, vec[k].second.s1, vec[k].second.s2);
			dat[find(vec[k].first.second)] += vec[k].second;
		}
		int r = find(face[p[i]]);
		// printf("r = %d\n", r);
		if (pz[p[i]] > h[i]) ans[i] = dat[r].eval(h[i]);
		else ans[i] = -1e9;
	}
	
	for (int i = 0; i < q; ++i) {
		if (ans[i] < -1e6) puts("-1");
		else printf("%.10Lf\n", ans[i]);
	}
	return 0;
}