#include<bits/stdc++.h>
using namespace std;


struct pt{
    long long x, y;
    bool operator<(const pt & p) const {
		return tie(x, y) < tie(p.x, p.y);
	}
	bool operator==(const pt & p) const {
		return tie(x,y) == tie(p.x, p.y);
	}
    pt operator + (const pt & p) const {
        return pt{x + p.x, y + p.y};
    }
    pt operator - (const pt & p) const {
        return pt{x - p.x, y - p.y};
    }
    long long cross(const pt & p) const {
        return x * p.y - y * p.x;
    }
    long long cross(const pt & a, const pt & b) const{
		return (a-*this).cross(b-*this);
	}
};

long long det(const pt &a, const pt &b, const pt &c){
	return a.cross(b, c);
}

int sgn(long long d){
	return (d > 0) - (d < 0);
}


struct Line {
	int a, b; long long c;
};

bool half(Line m){return m.a < 0 || (m.a == 0 && m.b < 0);};

bool operator<(Line m, Line n){
	return make_pair(half(m), (long long)m.b * n.a) <
		   make_pair(half(n), (long long)m.a * n.b);
}



Line LineFromPoints(int x1, int y1, int x2, int y2) {
	int a = y1 - y2, b = x2 - x1;
	long long c = (long long)a * x1 + (long long)b * y1;
	return {a, b, c}; // halfplane points to the l e f t of vec .
}

vector<pt>minkowski(const vector<pt> &P, const vector<pt> &Q){
	int n = P.size(), m = Q.size();
	vector<pt>res = {P[0] + Q[0]};
	for(int i = 1, j = 1; i < n || j < m; ){
		if(i < n && (j == m ||
			(P[i] - P[i-1]).cross(Q[j] - Q[j-1]) < 0)){
			res.push_back(res.back() + P[i] - P[i-1]);
			++i;
		} else {
			res.push_back(res.back() + Q[j] - Q[j-1]);
			++j;
		}
	}
	return res;
}

vector<pt> merge(const vector<pt> &a, const vector<pt> &b){
	vector<pt> res;
	int n = a.size(), m = b.size();
	int j = 0;
	for(int i = 0; i < n; i++){
		while(j < m && b[j] < a[i])res.push_back(b[j++]);
		if(j < m && b[j] == a[i])continue;
		res.push_back(a[i]);
	}
	while(j < m)res.push_back(b[j++]);
	return res;
}

vector<pt>convexHull(vector<pt> P, bool sorted=false){
	if(!sorted){
		sort(P.begin(), P.end());
		P.erase(unique(P.begin(), P.end()), P.end());
	}
	if(P.size() <= 1)return P;
	vector<pt>ret;
	for(auto p : P){
		while(ret.size() > 0 && p.y >= ret.back().y)ret.pop_back();
		while(ret.size() >= 2 && sgn(det(ret.end()[-2], ret.end()[-1], p)) > 0)ret.pop_back();
		ret.push_back(p);
	}
	return ret;
}
	
pt bestie(const vector<pt> &hull, Line L){
	int l = 0, r = hull.size()-1;
	while(l <= r){
		int m = (l + r)/2;
		Line M = LineFromPoints(hull[m].x, hull[m].y, hull[m+1].x, hull[m+1].y);
		if(M < L)r = m - 1;
		else l = m + 1;
	}
	return hull[(l >= (int)hull.size()? l - 1: l)];
}

int n;






bool check(const pt &p, const Line &L){
	return ((__int128)p.x * L.a + (__int128)p.y * L.b) >= L.c;
}

const vector<pt>org = {pt{0, 0}};

struct SegTree{
	vector<vector<pt>> items; int n;
	vector<vector<pt>> merc;
	SegTree(int n) : merc(2*n, org), items(2 * n, org), n(n){}
	

	
	void build_items(){
		for(int i = n - 1; i > 0; i--)items[i] = minkowski(items[2*i], items[2*i + 1]);
	}

	void build_merc(){
		for(int i = n - 1; i > 0; i--){
			merc[i] = convexHull(merge(minkowski(merc[2 * i], items[2 * i + 1]), merc[2* i + 1]), true);
		}
	}

	
	vector<pt> sum(int b, int e) {
		vector<pt>r1 = org, r2 = org;
		for(b += n, e += n; b < e; b /= 2, e /= 2){
			if(b%2) r1 = minkowski(r1, items[b++]);
			if(e%2) r2 = minkowski(items[--e], r2);
		}
		return minkowski(r1, r2);
	}
	
	int solve(int city, pt shift, Line L, int v, int tl, int tr, int l, int r){
		if(l > r)return -1;
		if(l == tl && r == tr){
			if(!check(bestie(merc[v], L) + shift, L)){
				return -1;
			}
			if(tl == tr)return tl;
		}
		int tm = (tl + tr)/2;
		int right = solve(city, shift, L, v * 2 +1, tm+1, tr, max(l, tm+1), r);
		if(right != -1)return right;
		shift = shift + bestie(sum(max(l, tm+1), r+1), L);
		return solve(city, shift, L, v*2, tl, tm, l, min(r, tm));
	}
		
	
};

SegTree tree(0);



int main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cin >> n;
	int N = n;
	while(__builtin_popcount(N) != 1)N++;
	tree = SegTree(N);
	for(int i = 0; i < n; i++){
		int x, y;
		cin >> x >> y;
		tree.merc[N+i] = {pt{x, y}};
		if(i + 1 == n)break;
		int r;
		cin >> r;
		vector<pt> pts(r);
		for(auto &p : pts){
			cin >> p.x >> p.y;
		}
		tree.items[N+i+1]= convexHull(pts);
	}
	tree.build_items();
	tree.build_merc();
	int q;
	cin >> q;
	while(q--){
		int v; int a, b;
		long long c;
		cin >> v >> a >> b >> c;
		Line L{a, b, c};
		int ans = tree.solve(v, pt{0, 0}, L, 1, 0, n-1, 0, v-1);
		cout << (ans == -1? -1 : ans + 1) << '\n';
		
	}
	return 0;
}