#include <bits/stdc++.h>
//#define int long long
#define endl "\n"
using namespace std;

using ll = long long;
const int INF = 1e9;
const int N = 5e3 + 5;
const double eps = 1e-9;

struct Point {
    double x, y;
    using Vec = Point;

    Point operator + (const Point& p) {
        return {x + p.x, y + p.y};
    }

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

    Point operator * (const double k) {
        return {x * k, y * k};
    }

    Point operator / (const int k) {
        return {x / k, y / k};
    }

    double dot(const Point& p) {
        return x * p.x + y * p.y;
    }

    double cross(const Vec& p) {
        return x * p.y - y * p.x;
    }

    double dis(const Point& p) {
        return sqrt(dis2(p));
    }

    double dis2(const Point& p) {
        return pow(x - p.x, 2) + pow(y - p.y, 2);
    }

    double len() {
        return sqrt(len2());
    }

    double len2() {
        return pow(x, 2) + pow(y, 2);
    }

    void show() {
        cout << x << " " << y << endl;
    }
} points[N];
using Vec = Point;

double pToSegDis(Point& p, Point& a, Point& b) {
    Point s;
    if (a.x == b.x) {
        s = {a.x - p.x, 0};
    }
    else if (a.y == b.y) {
        s = {0, a.y - p.y};
    }
    else {
        double k = -1 / ((a.y - b.y) / (a.x - b.x));
        double d = abs((b - a).cross(p - a)) / a.dis(b);
        double m = sqrt(1 + k * k);
        double n = d / m;   
        s = Point({1, k}) * n;
    }
    Point h = p + s;
    double res = (b - a).dot(h - a) / a.dis2(b);

    if (res <= -eps)
        return p.dis2(a);
    else if (res >= 1 + eps)
        return p.dis2(b);
    else 
        return p.dis2(h);
}

int main() {
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);

    int n, q;
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        cin >> points[i].x >> points[i].y;
    }
    points[n + 1] = points[1];

    for (int i = 1; i <= q; i++) {
        Point p, q;
        cin >> p.x >> p.y >> q.x >> q.y;
        Point o = (p + q) / 2;
        double r = p.dis(q) / 2;
        double res = INF;
        bool flag = false;
        for (int j = 1; j <= n; j++) {
            if ((points[j + 1] - points[j]).cross(o - points[j]) <= eps) {
                flag = true;
            }
            double d = pToSegDis(o, points[j], points[j + 1]);
            res = min(res, d);
        }
        if (!flag)
            res = 0;
        res += r * r / 2;
        cout << fixed << setprecision(10) << res << endl;
    }

    return 0;
}