#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db; 

const db PI = acos(-1.0);
const db EPS = 1e-9;
const db INF = 1e47;

void updMin(db& a, db b)
{
	a = min(a, b);
}

struct Pt
{
	db x, y;
	Pt operator+(const Pt& p) const
	{
		return {x + p.x, y + p.y};
	}
	Pt operator-(const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
	Pt operator*(db d) const
	{
		return {x * d, y * d};
	}
	Pt operator/(db d) const
	{
		return {x / d, y / d};
	}
};

db sq(const Pt& p)
{
	return p.x * p.x + p.y * p.y;
}

db abs(const Pt& p)
{
	return sqrt(sq(p));
}

int sgn(db x)
{
	return (EPS < x) - (x < -EPS);
}

Pt perp(const Pt& p)
{
	return {-p.y, p.x};
}

db dot(const Pt& p, const Pt& q)
{
	return p.x * q.x + p.y * q.y;
}

db cross(const Pt& p, const Pt& q)
{
	return p.x * q.y - p.y * q.x;
}

db orient(const Pt& p, const Pt& q, const Pt& r)
{
	return cross(q - p, r - p) / abs(q - p);
}

struct Line
{
	Pt n;
	db c;
	Line(const Pt& p, const Pt& q):
		n(perp(q - p)), c(-dot(n, p)) {}
	db side(const Pt& p) const
	{
		return dot(n, p) + c;
	}
	db dist(const Pt& p) const
	{
		return abs(side(p)) / abs(n);
	}
	bool cmpProj(const Pt& p, const Pt& q) const
	{
		return sgn(cross(p, n) - cross(q, n)) < 0;
	}
	/*Pt proj(const Pt& p) const
	{
		return p - n * side(p) / sq(n);
	}*/
};

/*bool inDisk(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(dot(a - p, b - p)) <= 0;
}

bool onSegment(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(orient(a, b, p)) == 0 && inDisk(a, b, p);`
}*/

db segPt(const Pt& a, const Pt& b, const Line& l, const Pt& p)
{
	if (l.cmpProj(a, p) && l.cmpProj(p, b))
		return l.dist(p);
	return min(abs(p - a), abs(p - b));
}

bool inConvexPolygon(const vector<Pt>& v, const Pt& a)
{
	assert(SZ(v) >= 3);
	if (sgn(orient(v.back(), v[0], a)) < 0
		|| sgn(orient(v[0], v[1], a)) < 0)
		return false;
	int i = lower_bound(v.begin() + 2, v.end(),
		a, [&](const Pt& p, const Pt& q)
	{
		return sgn(orient(v[0], p, q)) > 0;
	}) - v.begin();
	return sgn(orient(v[i - 1], v[i], a)) >= 0;
}

inline db f(db r, db d, db x)
{
	return sqrt(r * r - x * x) * (d - x) * (d - x);
}

db g(db r, db d)
{
	const int N = 47444;
	db a = -r, b = r, h = (b - a) / N, r2 = r * r;
	auto f = [&](db x)
	{
		return sqrt(r2 - x * x) * (d - x) * (d - x);
	};
	db res = f(a) + f(b);
	FOR(i, 1, N)
	{
		res += (i & 1 ? 4 : 2) * f(a + i * h);
	}
	return res * h / 3;
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout << fixed << setprecision(10);
	int n, m;
	cin >> n >> m;
	vector<Pt> v(n);
	for (Pt& p : v)
		cin >> p.x >> p.y;
	vector<Line> lines;
	FOR(i, 0, n)
		lines.PB({v[i], v[(i + 1) % n]});
	const db HALF_SQRT2 = sqrt(2) / 2;
	while (m--)
	{
		Pt p1, p2;
		cin >> p1.x >> p1.y >> p2.x >> p2.y;
		Pt p = (p1 + p2) / 2;
		db r = abs(p2 - p1) / 2;
		db d = 1e47;
		if (inConvexPolygon(v, p))
			d = 0;
		else
		{
			FOR(i, 0, n)
			{
				int j = i + 1 == n ? 0 : i + 1;
				d = min(d, segPt(v[i], v[j], lines[i], p));
			}
		}
		cout << 4 * g(r, HALF_SQRT2 * d) / (PI * r * r) << "\n";
	}
	return 0;
}