#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);};

void normalize(Line& m) {
	long long g = __gcd((long long)__gcd(abs(m.a), abs(m.b)), abs(m.c));
	if (half(m)) g *= -1;
	m.a /= g, m.b /= g, m.c /= g;
}

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();
	if(n == 0 || m == 0)return {};
	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)];
}

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

int n;

vector<pt>items[1+(1<<19)];
vector<pt>merc[1+(1<<19)];

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

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]));
}

vector<pt>query(int l, int r){
	vector<pt>res = org;
	for(l += n, r += n; l < r; l >>= 1, r >>= 1){
		if(l&1)res = minkowski(res, items[l++]);
		if(r&1)res = minkowski(res, items[--r]);
	}
	return res;
}

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(query(max(l, tm+1), r + 1), L);
	return solve(city, shift, L, v*2, tl, tm, l, min(r, tm));
}


int main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cin >> n;
	int N = n;
	while(__builtin_popcount(N)!=1)N++;
	items[N] = org;
	for(int i = 0; i < n; i++){
		int x, y;
		cin >> x >> y;
		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;
		items[N+i+1] = convexHull(pts);
	}
	for(int i = n; i < N; i++)items[N + i] = org;
	

	n = N;
	build_items();
	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 = solve(v, pt{0, 0}, L, 1, 0, n-1, 0, v-1);
		cout << (ans == -1? -1 : ans + 1) << '\n';
		
	}
	return 0;
}