#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

#define int int64_t

struct Vector {
  int x;
  int y;

  Vector(int x = 0, int y = 0): x(x), y(y) {}
};

Vector operator-(const Vector& a, const Vector& b) {
  return {a.x - b.x, a.y - b.y};
}

Vector operator+(const Vector& a, const Vector& b) {
  return {a.x + b.x, a.y + b.y};
}

int operator*(const Vector& a, const Vector& b) {
  return a.x * b.x + a.y * b.y;
}

int operator%(const Vector& a, const Vector& b) {
  return a.x * b.y - a.y * b.x;
}

int sgn(const Vector& a, const Vector& b) {
  __int128 res = a.x * b.y - a.y * b.x;
  if (res < 0) return -1;
  if (res == 0) return 0;
  return 1;
}

bool operator<(const Vector& a, const Vector& b) {
  if (a.x == b.x) {
    return a.y > b.y;
  }
  return a.x < b.x;
}

vector<Vector> operator+(const vector<Vector>& a, const vector<Vector>& b) {
  vector<Vector> res;
  res.push_back(a[0] + b[0]);
  int ia = 1, ib = 1;
  while (ia < (int)a.size() || ib < (int)b.size()) {
    if (ia == (int)a.size()) {
      res.push_back(res.back() + b[ib] - b[ib - 1]);
      ++ib;
    } else if (ib == (int)b.size()) {
      res.push_back(res.back() + a[ia] - a[ia - 1]);
      ++ia;
    } else if ((a[ia] - a[ia - 1]) % (b[ib] - b[ib - 1]) < 0) {
      res.push_back(res.back() + a[ia] - a[ia - 1]);
      ++ia;
    } else {
      res.push_back(res.back() + b[ib] - b[ib - 1]);
      ++ib;
    }
  }
  return res;
}

vector<Vector> hull_sorted(const vector<Vector>& a) {
  vector<Vector> st;
  int sz = 0;
  for (Vector p : a) {
    while (sz >= 2 && sgn((p - st[sz - 1]), (st[sz - 1] - st[sz - 2])) <= 0) {
      st.pop_back();
      --sz;
    }
    st.push_back(p);
    ++sz;
  }
  return st;
}

vector<Vector> unite(const vector<Vector>& a, const vector<Vector>& b) {
  vector<Vector> c;
  merge(a.begin(), a.end(), b.begin(), b.end(), back_inserter(c));
  return hull_sorted(c);
}

const int MAXN = 2e5 + 100;
Vector hero[MAXN];
vector<Vector> shop[MAXN];
vector<Vector> tr_shop[MAXN * 4];
vector<Vector> tr_hero[MAXN * 4];

void build(int v, int vl, int vr) {
  if (vr - vl == 1) {
    sort(shop[vl].begin(), shop[vl].end());
    tr_shop[v] = hull_sorted(shop[vl]);
    vector<Vector> h = {hero[vl]};
    tr_hero[v] = h + tr_shop[v];
    return;
  }
  int vm = (vl + vr) / 2;
  build(v * 2, vl, vm);
  build(v * 2 + 1, vm, vr);
  tr_shop[v] = tr_shop[v * 2] + tr_shop[v * 2 + 1];
  tr_hero[v] = unite(tr_hero[2 * v] + tr_shop[2 * v + 1], tr_hero[2 * v + 1]);
}

int norm(int x, int n) {
  return x >= n ? x - n : x;
}

int get_tan(const Vector& v, const vector<Vector>& p) {
  int i = 0;
  int k = 0;
  int n = p.size();
  while ((1 << k) < n) ++k;
  while (k >= 0) {
    int i1 = norm((i + (1 << k)), n);
    int i2 = (i - (1 << k) + 2 * n) % n;
    if (v * p[i1] > v * p[i]) i = i1;
    if (v * p[i2] > v * p[i]) i = i2;
    --k;
  }
  return p[i] * v;
}

int get_pref(int v, int vl, int vr, int r, const Vector& dir) {
  if (r <= vl) return 0;
  if (r >= vr) {
    return get_tan(dir, tr_shop[v]);
  }
  int vm = (vl + vr) / 2;
  int res1 = get_pref(v * 2, vl, vm, r, dir);
  int res2 = get_pref(v * 2 + 1, vm, vr, r, dir);
  return res1 + res2;
}

int get_last(int v, int vl, int vr, int r, const Vector& dir, int c) {
  if (r <= vl || (r >= vr && get_tan(dir, tr_hero[v]) < c)) return -1;
  if (vr - vl == 1) return vl;
  /// cerr << v << " " << vl << " " << vr << endl;
  int vm = (vl + vr) / 2;
  int res = get_last(v * 2 + 1, vm, vr, r, dir, c);
  if (res != -1) return res;
  c -= get_pref(v * 2 + 1, vm, vr, r, dir);
  return get_last(v * 2, vl, vm, r, dir, c);
}

istream& operator>>(istream& in, Vector& v) {
  in >> v.x >> v.y;
  return in;
}


signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);

  int n;
  cin >> n;
  for (int i = 0; i < n - 1; ++i) {
    cin >> hero[i];
    int sz;
    cin >> sz;
    shop[i].resize(sz);
    for (Vector& v : shop[i]) {
      cin >> v;
    }
  }
  cin >> hero[n - 1];
  build(1, 0, n - 1);
  /// cerr << "built" << endl; 

  int q;
  cin >> q;
  while (q--) {
    int ind, c;
    Vector dir;
    cin >> ind >> dir >> c;
    --ind;
    /// cerr << ind << " " << c << endl;
    if (dir * hero[ind] >= c) {
      cout << ind + 1 << "\n";
      continue;
    }
    /// cerr << "start" << endl;
    int res = get_last(1, 0, n - 1, ind, dir, c);
    /// cerr << "end" << endl;
    if (res == -1) {
      cout << "-1\n";
    } else {
      cout << res + 1 << "\n";
    }
  }

  
  return 0;
}