#pragma GCC optimize("Ofast")

#include "bits/stdc++.h"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define rep1n(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n) - 1; i >= 0; --i)
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define each(x, a) for (auto &x : a)
#define ar array
#define vec vector
#define range(i, n) rep(i, n)

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

// [l, r)
template<typename T, typename F>
T FindFirstTrue(T l, T r, const F &predicat) {
    --l;
    while (r - l > 1) {
        T mid = l + (r - l) / 2;
        if (predicat(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    return r;
}


template<typename T, typename F>
T FindLastFalse(T l, T r, const F &predicat) {
    return FindFirstTrue(l, r, predicat) - 1;
}


const ll INF = 2e18;
const int INFi = 1e9;
const int N = 8e5 + 5;
const int LG = 20;

struct Point {
    int x, y;

    Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}

    Point operator-(const Point &oth) const {
        return {x - oth.x, y - oth.y};
    }


    ll operator*(const Point &oth) const {
        return 1ll * x * oth.y - 1ll * y * oth.x;
    }
};

using pt = Point;

pt a[N];
int n;
const int M = 3e5 + 10;
pt s[M], f[M];
int ord[N];

int ordR[M];
int ordL[M];
int ans[M];

int tmp[M];

bool check1(int i, int j) {
    if (ans[i] != -1) return true;
    if (s[i].x > a[j].x || f[i].x < a[j].x) return false;
    if ((f[i] - s[i]) * (a[j] - s[i]) >= 0) {
        ans[i] = j;
        return true;
    }
    return false;
}

vector<int> stk;
int sz;

void AddRight(int p) {
    while (sz >= 2 && (a[stk[sz - 1]] - a[stk[sz - 2]]) * (a[p] - a[stk[sz - 2]]) >= 0) {
        stk.pop_back();
        sz--;
    }
    stk.push_back(p);
    sz++;
}

void checkRight(int i) {
    if (!sz || check1(i, stk.front()) || check1(i, stk.back())) return;
    if (sz <= 2) return;
    int l = -1;
    int r = (int) stk.size() - 1;
    pt v = f[i] - s[i];
    while (r - l > 1) {
        int m = (l + r) / 2;
        if ((a[stk[m + 1]] - a[stk[m]]) * v >= 0) {
            r = m;
        } else {
            l = m;
        }
    }
    check1(i, stk[r]);
}


void AddLeft(int p) {
    while (sz >= 2 && (a[stk[sz - 1]] - a[stk[sz - 2]]) * (a[p] - a[stk[sz - 2]]) <= 0) {
        stk.pop_back();
        sz--;
    }
    stk.push_back(p);
    sz++;
}

void checkLeft(int i) {
    if (!sz || check1(i, stk.front()) || check1(i, stk.back())) return;
    if (sz <= 2) return;
    int l = -1;
    int r = (int) stk.size() - 1;
    pt v = f[i] - s[i];
    while (r - l > 1) {
        int m = (l + r) / 2;
        if ((a[stk[(int) stk.size() - 1 - (m + 1)]] - a[stk[(int) stk.size() - 1 - m]]) * v >= 0) {
            r = m;
        } else {
            l = m;
        }
    }
    check1(i, stk[(int) stk.size() - 1 - r]);
}

void solve(int l, int r, int lq, int rq) {
    if (l >= r || lq >= rq) return;
    if (l + 1 == r) {
        for (int i = lq; i < rq; ++i) {
            check1(ordL[i], l);
        }
        return;
    }

    int m = (l + r) / 2;
    ll xm = a[m].x;

    {
        int j = lq;
        sz = 0;
        stk.clear();
        for (int i = m; i < r; ++i) {
            while (j < rq && f[ordR[j]].x < a[i].x) {
                if (s[ordR[j]].x < xm) checkRight(ordR[j]);
                j++;
            }
            AddRight(i);
        }
        while (j < rq) {
            if (s[ordR[j]].x < xm) checkRight(ordR[j]);
            j++;
        }
    }
    {
        sz = 0;
        stk.clear();
        int j = rq - 1;
        for (int i = m - 1; i >= l; --i) {
            while (j >= lq && s[ordL[j]].x > a[i].x) {
                if (f[ordL[j]].x > xm) checkLeft(ordL[j]);
                j--;
            }
            AddLeft(i);
        }
        while (j >= lq) {
            if (f[ordL[j]].x > xm) checkLeft(ordL[j]);
            j--;
        }
    }

    int mL = lq;
    for (int i = lq; i < rq; ++i) {
        if (f[ordL[i]].x < xm) {
            tmp[mL++] = ordL[i];
        }
    }
    int eL = mL;
    for (int i = lq; i < rq; ++i) {
        if (s[ordL[i]].x > xm) {
            tmp[eL++] = ordL[i];
        }
    }
    for (int i = lq; i < rq; ++i) ordL[i] = tmp[i];

    int mR = lq;
    for (int i = lq; i < rq; ++i) {
        if (f[ordR[i]].x < xm) {
            tmp[mR++] = ordR[i];
        }
    }
    int eR = mR;
    for (int i = lq; i < rq; ++i) {
        if (s[ordR[i]].x > xm) {
            tmp[eR++] = ordR[i];
        }
    }
    for (int i = lq; i < rq; ++i) ordR[i] = tmp[i];
    assert(mL == mR && eL == eR);

    solve(l, m, lq, mL);
    solve(m, r, mL, eL);
}

void solve() {
    cin >> n;
    rep(i, n) cin >> a[i].x >> a[i].y;
    iota(ord, ord + n, 0);
    sort(ord, ord + n, [&](const int &i, const int &j) { return a[i].x < a[j].x; });
    sort(a, a + n, [&](const pt &i, const pt &j) { return i.x < j.x; });

    int m;
    cin >> m;
    rep(i, m) {
        cin >> s[i].x >> s[i].y >> f[i].x >> f[i].y;
        if (s[i].x > f[i].x) {
            swap(s[i], f[i]);
        }
    }
    iota(ordL, ordL + m, 0);
    sort(ordL, ordL + m, [&](const int &i, const int &j) { return s[i].x < s[j].x; });
    iota(ordR, ordR + m, 0);
    sort(ordR, ordR + m, [&](const int &i, const int &j) { return f[i].x < f[j].x; });
    rep(i, m) ans[i] = -1;

    solve(0, n, 0, m);
    rep(i, m) {
        if (ans[i] != -1) ans[i] = ord[ans[i]] + 1;
        cout << ans[i] << '\n';
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(12) << fixed;
    int t = 1;
//    cin >> t;
    rep(i, t) {
        solve();
    }
//    cout << sizeof(a) / 1'000'000 << '\n';
    return 0;
}