#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


#define x first
#define y second

int N;
vector<pair<int, int>> P;
int Q;
vector<pair<int, int>> S, T;

Int tri(int u, int v, int w) {
  return (Int)(P[v].x - P[u].x) * (P[w].y - P[u].y)
       - (Int)(P[v].y - P[u].y) * (P[w].x - P[u].x);
}

int main() {
  for (; ~scanf("%d", &N); ) {
    P.resize(N);
    for (int u = 0; u < N; ++u) {
      scanf("%d%d", &P[u].x, &P[u].y);
    }
    scanf("%d", &Q);
    S.resize(Q);
    T.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d%d%d", &S[q].x, &S[q].y, &T[q].x, &T[q].y);
    }
    
    vector<int> us(N);
    for (int u = 0; u < N; ++u) us[u] = u;
    sort(us.begin(), us.end(), [&](int u, int v) -> bool {
      return (P[u].x < P[v].x);
    });
    auto lb = [&](int x) -> int {
      return partition_point(us.begin(), us.end(), [&](int u) -> bool {
        return (P[u].x < x);
      }) - us.begin();
    };
    vector<int> A(Q), B(Q);
    for (int q = 0; q < Q; ++q) {
      if (S[q].x > T[q].x) swap(S[q], T[q]);
      A[q] = lb(S[q].x);
      B[q] = lb(T[q].x);
    }
// cerr<<"us = "<<us<<endl;
// cerr<<"A = "<<A<<endl;
// cerr<<"B = "<<B<<endl;
    
    vector<int> ans(Q, -2);
    
    vector<pair<int, int>> lqss(2 * Q);
    vector<int> hull(N);
    for (int e = 0; 1<<e <= N; ++e) {
      int lqssLen = 0;
      for (int q = 0; q < Q; ++q) {
        if (A[q] < B[q] && (A[q] & 1<<e)) {
          lqss[lqssLen++] = make_pair(A[q], q);
          A[q] += (1<<e);
        }
        if (A[q] < B[q] && (B[q] & 1<<e)) {
          B[q] -= (1<<e);
          lqss[lqssLen++] = make_pair(B[q], q);
        }
      }
      sort(lqss.begin(), lqss.begin() + lqssLen);
      for (int i = 0, j = 0; i < lqssLen; ) {
        for (; j < lqssLen && lqss[i].first == lqss[j].first; ++j) {}
        const int L = lqss[i].first;
        const int R = L + (1<<e);
        int hullLen = 0;
        for (int k = L; k < R; ++k) {
          for (; hullLen >= 2 && tri(hull[hullLen - 2], hull[hullLen - 1], us[k]) >= 0; --hullLen) {}
          hull[hullLen++] = us[k];
        }
// cerr<<L<<" "<<R<<": ";pv(hull.begin(),hull.begin()+hullLen);cerr<<"  ";pv(lqss.begin()+i,lqss.begin()+j);
        for (; i < j; ++i) {
          const int q = lqss[i].second;
          /*
            tri(S[q], T[q], P[*]) >= 0
            a x + b y >= c
          */
          const Int a = -(T[q].y - S[q].y);
          const Int b = T[q].x - S[q].x;
          const Int c = a * S[q].x + b * S[q].y;
          auto eval = [&](int k) -> Int {
            if (0 <= k && k < hullLen) {
              return a * P[hull[k]].x + b * P[hull[k]].y;
            } else {
              return -9009009009009009009LL;
            }
          };
          int l = -1, m = 0, r = hullLen;
          Int fm = eval(m);
          for (; r - l >= 3; ) {
            const int lm = l + (m - l) / 2;
            const int mr = r - (r - m) / 2;
            const Int flm = eval(lm);
            const Int fmr = eval(mr);
            if (flm > fm) {
              r = m;
              m = lm;
              fm = flm;
            } else if (fm < fmr) {
              l = m;
              m = mr;
              fm = fmr;
            } else {
              l = lm;
              r = mr;
            }
          }
// cerr<<"  q = "<<q<<"; a = "<<a<<", b = "<<b<<", c = "<<c<<"; m = "<<m<<endl;
          if (fm >= c) {
            ans[q] = hull[m];
          }
        }
      }
    }
    assert(A == B);
    
    for (int q = 0; q < Q; ++q) {
      printf("%d\n", ans[q] + 1);
    }
  }
  return 0;
}