#include <cmath>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <list>
#include <time.h>
#include <math.h>
#include <random>
#include <deque>
#include <queue>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
#include <iomanip>
#include <bitset>
#include <sstream>

using namespace std;

typedef long long ll;

mt19937 rnd(228);

struct pt
{
    int x, y;
};

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

ll abs(const pt &p)
{
    return p.x * (ll) p.x + p.y * (ll) p.y;
}

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

bool cmp(const pt &a, const pt &b)
{
    if (a.x != b.x)
    {
        return a.x < b.x;
    }
    else
    {
        return a.y < b.y;
    }
}

bool cw(pt a, pt b, pt c)
{
	return a.x * (ll) (b.y - c.y) + b.x * (ll) (c.y - a.y) + c.x * (ll) (a.y - b.y) < 0;
}

bool ccw(pt a, pt b, pt c)
{
	return a.x * (ll) (b.y - c.y) + b.x * (ll) (c.y - a.y) + c.x * (ll) (a.y - b.y) > 0;
}

vector <pt> p, up, down;

vector <pt> mrg(const vector <pt> &a, const vector <pt> &b)
{
    p.resize(a.size() + b.size());
    merge(a.begin(), a.end(), b.begin(), b.end(), p.begin(), cmp);
    return p;
}

vector <pt> hull(const vector <pt> &e)
{
    if ((int) e.size() <= 3) return e;
    up.clear();
    down.clear();
    p.clear();
    pt p1 = e[0], p2 = e.back();
    up.push_back(p1);
    down.push_back(p1);
    for (int i = 1; i < (int) e.size(); i++)
    {
        if (i == (int) e.size() - 1 || cw(p1, e[i], p2))
        {
            while ((int) up.size() >= 2 && !cw(up[(int) up.size() - 2], up[(int) up.size() - 1], e[i]))
            {
                up.pop_back();
            }
            up.push_back(e[i]);
        }
        if (i == (int) e.size() - 1 || ccw(p1, e[i], p2))
        {
            while ((int) down.size() >= 2 && !ccw(down[(int) down.size() - 2], down[(int) down.size() - 1], e[i]))
            {
                down.pop_back();
            }
            down.push_back(e[i]);
        }
    }
    down.erase(down.begin());
    down.pop_back();
    return mrg(up, down);
}

const int N = 1e5;

pt a[N];
vector <pt> t[4 * N];


void build(int v, int l, int r)
{
    if (r - l == 1)
    {
        t[v] = {a[l]};
    }
    else
    {
        int m = (l + r) / 2;
        build(v * 2 + 1, l, m);
        build(v * 2 + 2, m, r);
        t[v] = mrg(t[v * 2 + 1], t[v * 2 + 2]);
        t[v] = hull(t[v]);
    }
}

vector <pt> get(int v, int l, int r, int tl, int tr)
{
    if (tl >= r || tr <= l)
    {
        return {};
    }
    if (tl >= l && tr <= r)
    {
        return t[v];
    }
    else
    {
        int tm = (tl + tr) / 2;
        return mrg(get(v * 2 + 1, l, r, tl, tm), get(v * 2 + 2, l, r, tm, tr));
    }
}

int n;

vector <pt> get(int l, int r)
{
    vector <pt> b = get(0, l, r + 1, 0, n);
    b = hull(b);
    return b;
}

int main()
{
#ifdef ONPC
    freopen("a.in", "r", stdin);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i].x >> a[i].y;
    }
    build(0, 0, n);
    int q;
    cin >> q;
    while (q--)
    {
        int l, r;
        cin >> l >> r;
        l--, r--;
        auto b = get(l, r);
        ll ans = 0;
        for (int i = 0; i < (int) b.size(); i++)
        {
            for (int j = i + 1; j < (int) b.size(); j++)
            {
                ans = max(ans, abs(b[i] - b[j]));
            }
        }
        cout << ans << '\n';
    }
}