#define LOCAL
#include <bits/stdc++.h>
// #include <sys/resource.h>
#define fir first
#define sec second
#define el '\n'

#ifdef LOCAL
#define FINISH cerr << "FINISH" << endl;
#else
#define FINISH ;
#endif

#ifdef LOCAL
#define debug(x) cerr << setw(4) << #x << " == " << x << endl
#else
#define debug(x)
#endif

#ifdef LOCAL
#define debugv(x)                   \
	cerr << setw(4) << #x << ":: "; \
	for (auto i : x)                \
		cerr << i << " ";           \
	cerr << endl
#else
#define debugv(x)
#endif

// using namespace std;
typedef long long ll;

const int mod = 998244353;
const int inf = 0x3f3f3f3f;
const int N = 800010;
const int M = 300010;
struct point {
	int x, y;
	point operator+(const point &a) const
	{
		return {x + a.x, y + a.y};
	}
	point operator-(const point &a) const
	{
		return {x - a.x, y - a.y};
	}
	ll operator*(const point &a) const
	{
		return {1ll * x * a.x + 1ll * y * a.y};
	}
	ll operator^(const point &a) const
	{
		return {1ll * x * a.y - 1ll * y * a.x};
	}  // 注意优先级
	int toleft(const point &a) const
	{
		const auto t = (*this) ^ a;
		return (t > 0) - (t < 0);
	}
};
struct Data {
	point p;
	int idx;
	bool operator<(const Data a) const
	{
		return p.x < a.p.x;
	}
} a[N];
struct query {
	point st, ed;
	int l, r, idx, flag;
} q[M];
int answer[M];
void getans(int p, std::vector<int> &now, int l, int r, int ql, int qr)
{
	for (int rr = ql; rr <= qr; rr++) {
		if (q[rr].l > q[rr].r)
			continue;
		if (l < q[rr].l || r > q[rr].r)
			continue;
		if (answer[q[rr].idx])
			continue;
		point st = q[rr].st, ed = q[rr].ed;
		int l = 1, r = now.size() - 1;
		while (l < r) {	 // 找第一个斜率小于当前线段的
			int mid = (l + r) >> 1;
			ll res1 =
				1ll * (ed.y - st.y) * (a[now[mid]].p.x - a[now[mid - 1]].p.x);
			ll res2 =
				1ll * (ed.x - st.x) * (a[now[mid]].p.y - a[now[mid - 1]].p.y);
			if (res1 > res2) {
				r = mid;
			}
			else {
				l = mid + 1;
			}
		}
		l--;
		for (int i = std::max(0, l - 1);
			 i <= std::min(l + 1, (int)now.size() - 1); i++) {
			ll X = a[now[i]].p.x, Y = a[now[i]].p.y;
			if (1ll * (X - st.x) * (ed.y - st.y) <=
				1ll * (Y - st.y) * (ed.x - st.x)) {
				answer[q[rr].idx] = a[now[i]].idx;
			}
		}
	}
}
void build(std::vector<int> &st, std::vector<int> &r)
{
	const auto check = [&](const std::vector<int> &st, const int &u) {
		const auto back1 = a[st.back()].p, back2 = a[*prev(st.end(), 2)].p;
		return (back1 - back2).toleft(a[u].p - back1) > 0;
	};
	for (auto x : r) {
		while (st.size() > 1 && check(st, x))
			st.pop_back();
		st.push_back(x);
	}
}

int printMemoryUsage()
{
	int ans = 0;
	/*struct rusage usage;
	getrusage(RUSAGE_SELF, &usage);
	ans = usage.ru_std::maxrss;*/
	return ans;
}

void merge(int p, int l, int r, int ql, int qr, std::vector<int> &now)
{
	if (l == r) {
		now.push_back(l);
		getans(p, now, l, l, ql, qr);
		return;
	}
	int mid = (l + r) >> 1, st = ql;
	for (int i = ql; i <= qr; i++) {
		if (q[i].l > q[i].r)
			continue;
		if (q[i].l <= l && r <= q[i].r) {
			q[i].flag = 0, st++;
		}
		else if (q[i].r < l || r < q[i].l) {
			q[i].flag = 0, st++;
		}
		else {
			q[i].flag = 1;
		}
	}
	std::sort(q + ql, q + qr + 1,
			  [&](query x, query y) { return x.flag < y.flag; });
	merge(p << 1, l, mid, st, qr, now);
	std::vector<int> ri;
	merge(p << 1 | 1, mid + 1, r, st, qr, ri);
	build(now, ri);	 // 合并两个上凸壳
	ri.clear();
	ri.shrink_to_fit();
	getans(p, now, l, r, ql, st - 1);  // 查询被存在nowquery的答案
	now.shrink_to_fit();
	return;
}

void solve()
{
	int n, m;
	std::cin >> n;
	for (int i = 1; i <= n; i++) {
		std::cin >> a[i].p.x >> a[i].p.y;
		a[i].idx = i;
	}
	std::sort(a + 1, a + n + 1);
	int cnt = 0;
	std::vector<int> v(n + 1, 0);
	for (int i = 1; i <= n; i++) {
		v[i] = a[i].p.x;
	}
	std::cin >> m;
	int tmp = 0;
	for (int i = 1; i <= m; i++) {
		point st, ed;
		std::cin >> st.x >> st.y >> ed.x >> ed.y;
		if (st.x > ed.x)
			std::swap(st, ed);
		query now;
		now.st = st, now.ed = ed;
		int L = lower_bound(v.begin(), v.end(), st.x) - v.begin();
		int R = upper_bound(v.begin(), v.end(), ed.x) - v.begin() - 1;
		now.l = L, now.r = R, now.idx = i;
		if (st.x == ed.x) {
			if (L == R) {
				int idx = L, y = a[L].p.y;
				if (y >= std::min(st.y, ed.y) && y <= std::max(st.y, ed.y)) {
					answer[i] = idx;
				}
			}
			continue;
		}
		else {
			if (now.l <= now.r)
				q[tmp] = now, tmp++;
		}
	}
	v.clear();
	v.shrink_to_fit();
	std::vector<int> convex_hull;
	merge(1, 1, n, 0, tmp - 1, convex_hull);
	convex_hull.clear();
	convex_hull.shrink_to_fit();
	for (int i = 1; i <= m; i++) {
		if (answer[i])
			std::cout << answer[i] << el;
		else
			std::cout << "-1" << el;
	}
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);
	int T = 1;
	// std::cin >> T;
	while (T--) {
		solve();
	}
	return 0;
}