#include <bits/stdc++.h>

using namespace std;

#define y1 fuckcpp

const int MAX_N = 2000 + 5;
const double Pi = acos(-1);

int N, Q;
struct Node{
    int x, y, id;
    double angle;
    
    Node () {}
    Node (int x_, int y_, int id_) {
        x = x_; y = y_; id = id_;
        angle = atan2(y, x);
    }
    
    inline bool operator < (const Node &comp) const {
        return angle < comp.angle;
    }
}node[MAX_N];
double ans[MAX_N][MAX_N], dis[MAX_N][MAX_N];

bool check_pi(double x, double y) {
    // x in [y, y+Pi]
    if (y < -Pi) y += Pi * 2;
    if (y < 0) {
        return x >= y && x <= y + Pi;
    }
    return (x >= y || x <= y - Pi);
}

double query(int lx, int rx, int ly, int ry) {
    return ans[rx][ry] - ans[rx][ly - 1] - ans[lx - 1][ry] + ans[lx - 1][ly - 1];
}

double calc_dis(int x1, int y1, int x2, int y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

double calc_dis(int i, int j) {
    return calc_dis(node[i].x, node[i].y, node[j].x, node[j].y);
}

bool leftOf(int i, int j, int k) {
    // j is left of ik
    return (node[k].x - node[i].x) * (node[j].y - node[i].y) >= (node[k].y - node[i].y) * (node[j].x - node[i].x);
}

int main() {
    scanf("%d", &N);
    for (int i = 1; i <= N; i ++) {
        int x, y;
        scanf("%d%d", &x, &y);
        node[i] = Node(x, y, i);
    }
    sort(node + 1, node + N + 1);
    for (int i = 1; i <= N; i ++) {
        // counter-clockwise
        static int sta[MAX_N];
        int tp = 0; double len = 0;
        sta[++ tp] = i;
        for (int j = (i < N ? i + 1 : 1); j != i && check_pi(node[j].angle, node[i].angle); j = (j < N ? j + 1 : 1)) {
            while (tp > 1 && leftOf(sta[tp - 1], j, sta[tp])) {
                len -= calc_dis(sta[tp - 1], sta[tp]);
                tp --;
            }
            len += calc_dis(sta[tp], j);
            sta[++ tp] = j;
            dis[node[i].id][node[j].id] = len;
        }
        // clockwise
        tp = 0; len = 0; sta[++ tp] = i;
        for (int j = (i > 1 ? i - 1 : N); j != i && check_pi(node[j].angle, node[i].angle - Pi); j = (j > 1 ? j - 1 : N)) {
            while (tp > 1 && leftOf(sta[tp - 1], sta[tp], j)) {
                len -= calc_dis(sta[tp - 1], sta[tp]);
                tp --;
            }
            len += calc_dis(sta[tp], j);
            sta[++ tp] = j;
            dis[node[i].id][node[j].id] = len;
        }
    }
    for (int i = 1; i <= N; i ++) {
        for (int j = i; j <= N; j ++) {
            // assert(abs(dis[i][j] - dis[j][i]) <= 1);
            int end;
            double &x = ans[i][j];
            for (int &k = end = 8; k <= N; k += 8) {
                x = max(x, dis[i][k] + dis[j][k]);
                x = max(x, dis[i][k - 1] + dis[j][k - 1]);
                x = max(x, dis[i][k - 2] + dis[j][k - 2]);
                x = max(x, dis[i][k - 3] + dis[j][k - 3]);
                x = max(x, dis[i][k - 4] + dis[j][k - 4]);
                x = max(x, dis[i][k - 5] + dis[j][k - 5]);
                x = max(x, dis[i][k - 6] + dis[j][k - 6]);
                x = max(x, dis[i][k - 7] + dis[j][k - 7]);
            }
            for (int k = end - 7; k <= N; k ++) x = max(x, dis[i][k] + dis[j][k]);
            ans[j][i] = ans[i][j];
        }
    }
    for (int i = 1; i <= N; i ++) {
        for (int j = 1; j <= N; j ++) {
            ans[i][j] += ans[i - 1][j] + ans[i][j - 1] - ans[i - 1][j - 1];
        }
    }
    scanf("%d", &Q);
    while (Q --) {
        int a, b, c, d;
        scanf("%d%d%d%d", &a, &b, &c, &d);
        printf("%.10lf\n", query(a, b, c, d) / (b - a + 1) / (d - c + 1));
    }
    // cerr << clock() << endl;
    return 0;
}

/*
5
7 0
3 3
0 7
-3 3
-7 0
6
1 1 3 3
3 3 4 4
1 1 5 5
5 5 2 2
2 2 4 4
1 5 1 5
*/