#include <bits/stdc++.h>
using namespace std;
typedef double T;
typedef long double ld;

inline int rd() {
    int x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

#define let  const auto
#define lett const T
#define letp const P // P for Point
#define lets const S // S for Segment
#define letl const L // L for Line
#define letc const C // C for Convex

const T eps = 1e-8;
const double PI = 3.1415926535897932384;
#define z(x) (abs((x)) <= eps) // is zero

inline double sqr(double x) {return x * x;}

struct P {
    T x, y;
    P (T x = 0, T y = 0) : x(x), y(y) {}
    P operator + (letp &p) const {return {x + p.x, y + p.y};} 
    P operator - (letp &p) const {return {x - p.x, y - p.y};} 
    P operator * (lett &d) const {return {x * d, y * d};}
    P operator / (lett &d) const {return {x / d, y / d};}
    P operator - () const {return {-x, -y};}

    T operator | (letp &p) const {return x * p.x + y * p.y;} // dot
    T operator ^ (letp &p) const {return x * p.y - y * p.x;} // cross
    
    bool operator == (letp &p) const {return z(x - p.x) && z(y - p.y);}
    bool operator != (letp &p) const {return ! operator == (p);}
    bool operator < (letp &p) const {return z(x - p.x) ? y < p.y : x < p.x;}
    bool operator > (letp &p) const {return !(*this < p || *this == p);}
   
    // left(counterclockwise) = 1 | on = 0 | right(clockwise) = -1
    int ori(letp &p) const {T t = (*this) ^ p; return (t > eps) - (t < -eps);}

    T norm() const {return x * x + y * y;}
    T dis(letp &p) const {return sqrt(((*this) - p).norm());}
    P proj (letp &p) const {return (*this) * (((*this) | p) / norm());}
    P refl (letp &p) const {return proj(p) * 2 - p;}
} zero;

double abs(letp &p) {return sqrt(p.norm());}
P unit(letp &p) {return p / abs(p);}
P perp(letp &p) {return {-p.y, p.x};} // turn pi / 2 left(counterclockwise)
P perpr(letp &p) {return {p.y, -p.x};} // turn pi / 2 right(clockwise)

bool orth(letp &p, letp &q) {return z(p | q);} // orthogonal
bool para(letp &p, letp &q) {return z(p ^ q);} // parallel

struct argcmp { // compared by polar angle
    bool operator() (letp &a, letp &b) const {
        const auto quad = [](letp &a) {
            if (a.y < -eps) return 1; // halfplane with negative y
            if (a.y > eps) return 4;  // halfplane with positive y
            if (a.x < -eps) return 5; // negative x-axis
            if (a.x > eps) return 3;  // positive x-axis
            return 2; // origin
        };
        const int qa = quad(a), qb = quad(b);
        if (qa != qb) return qa < qb; 
        const auto t = (a ^ b); //in the same quad
        /* sorted by length in increasing order when parallel
        if (z(t)) return norm(a) < norm(b) - eps; */
        return t > eps;
    }    
};

struct L {
    P p, v;
    int ori (letp &a) const {return v.ori(a - p);} 
    P inter(letl &l) const {return p + v * ((l.v ^ (p - l.p)) / (v ^ l.v));} 
    L shift(letp &d) const {return {p + d, v};}
    L shiftl(double d) const {return {p + perp(v) * d / abs(v), v};}
    P proj(letp &a) const {return p + v.proj(a - p);}
    P refl(letp &a) const {return p + v.refl(a - p);} 
    double dis(letp &a) const {return abs(v ^ (a - p)) / abs(v);} 
    double dis2(letp &a) const {return sqr(v ^ (a - p)) / (v).norm();} 
    L perpl() const {return {p, perp(v)};}
};

bool orth(letl &p, letl &q) {return z(p.v | q.v);} // orthogonal
bool para(letl &p, letl &q) {return z(p.v ^ q.v);} // parallel


struct S {
    P a, b;

    // on endPs = -1 | out = 0 | in = 1
    int is_on(letp &p) const {
        if (p == a || p == b) return -1;
        return (p - a).ori(p - b) == 0 && ((p - a) | (p - b)) < -eps;
    }

    // inter on endPs = -1 | not inter = 0 | inter inside = 1
    int is_inter(letl &l) const {
        if (l.ori(a) == 0 || l.ori(b) == 0) return -1;
        return l.ori(a) != l.ori(b);
    }

    // inter on endPs = -1 | not inter = 0 | inter inside = 1
    int is_inter(lets &s) const {
        if (is_on(s.a) || is_on(s.b) || s.is_on(a) || s.is_on(b)) return -1;
        letl &l{a, b - a}, ls{s.a, s.b - s.a};
        return l.ori(s.a) * l.ori(s.b) == -1 && ls.ori(a) * ls.ori(b) == -1;
    }

    double dis(letp &p) const {
        if (((p - a) | (b - a)) < -eps || ((p - b) | (a - b)) < -eps) 
            return min(abs(a - p), abs(b - p));
        return L{a, b - a}.dis(p);
    }

    double dis2(letp &p) const {
        if (((p - a) | (b - a)) < -eps || ((p - b) | (a - b)) < -eps) 
            return min((a - p).norm(), (b - p).norm());
        return L{a, b - a}.dis2(p);
    }

    double dis(lets &s) const {
        if (is_inter(s)) return 0.0;
        return min({dis(s.a), dis(s.b), s.dis(a), s.dis(b)});
    }
};

struct Polygon {
    vector<P> p; // counterclockwise
    Polygon(const vector<P> p = {}) : p(p) {}
    size_t nxt(const size_t i) const {return i == p.size() - 1 ? 0 : i + 1;}
    size_t pre(const size_t i) const {return i == 0 ? p.size() - 1 : i - 1;}

    bool is_convex() const {
        bool pos = false, neg = false;
        for (size_t i = 0; i < p.size(); ++i) {
            int o = (p[i] - p[pre(i)]).ori(p[nxt(i)] - p[i]);
            if (o == 1) pos = true;
            if (o == -1) neg = true;
        }
        return !(pos && neg);
    }
};

#define N 100007
#define fr first
#define sc second
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

struct C : Polygon {
    C (const vector<P> &p = {}) : Polygon(p) {}

    double dis(letp &tar) const {
        bool fl = true;
        double ans = 1e18;
        for (size_t i = 0; i < p.size(); ++i) {
            ans = min(ans, S{p[i], p[pre(i)]}.dis(tar));
            if (L{p[i], p[nxt(i)] - p[i]}.ori(tar) < 0) fl = false;
        }
        return fl ? 0 : ans;
    }

} A;

int main() {
    int n = rd(), q = rd();
    A.p.resize(n);
    rep(i, 0, n - 1) {A.p[i].x = rd(); A.p[i].y = rd();}
    rep(i, 1, q) {
        P a, b, c;
        a.x = rd(); a.y = rd();
        b.x = rd(); b.y = rd();
        c = (a + b) / 2;
        double ans = (c - a).norm() / 2;
        ans += sqr(A.dis(c));
        printf("%.10lf\n", ans); 
    }
    return 0;
}