#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;

long double EPS = 1e-5;

class Point {
public:
	long double px, py;
	Point() : px(0), py(0) {};
	Point(long double px_, long double py_) : px(px_), py(py_) {};
	bool operator==(const Point& p) const { return fabs(px - p.px) < EPS && fabs(py - p.py) < EPS; }
	bool operator!=(const Point& p) const { return fabs(px - p.px) > EPS || fabs(py - p.py) > EPS; }
	bool operator<(const Point& p) const { return p.px - px > EPS ? true : (fabs(px - p.px) < EPS && p.py - py > EPS); }
	bool operator>(const Point& p) const { return px - p.px > EPS ? true : (fabs(px - p.px) < EPS && py - p.py > EPS); }
	bool operator<=(const Point& p) const { return !(Point(px, py) > p); }
	bool operator>=(const Point& p) const { return !(Point(px, py) < p); }
	Point operator+(const Point& p) const { return Point(px + p.px, py + p.py); }
	Point operator-(const Point& p) const { return Point(px - p.px, py - p.py); }
	Point operator/(long double d) const { return Point(px / d, py / d); }
	friend Point operator*(const Point p, long double d) { return Point(p.px * d, p.py * d); }
	friend Point operator*(long double d, const Point& p) { return p * d; }
	Point& operator+=(const Point& p1) { px += p1.px, py += p1.py; return *this; }
	Point& operator-=(const Point& p1) { px -= p1.px, py -= p1.py; return *this; }
	Point& operator*=(long double d) { px *= d, py *= d; return *this; }
	Point& operator/=(long double d) { px /= d, py /= d; return *this; }
};
class Line {
public:
	Point p1, p2;
	Line() : p1(Point()), p2(Point()) {};
	Line(Point p1_, Point p2_) : p1(p1_), p2(p2_) {};
	Line(long double p1x, long double p1y, long double p2x, long double p2y) : p1(Point(p1x, p1y)), p2(Point(p2x, p2y)) {};
	bool operator==(const Line& s) const { return (p1 == s.p1 && p2 == s.p2) || (p1 == s.p2 && p2 == s.p1); }
	bool operator!=(const Line& s) const { return !(Line(p1, p2) == s); }
};

long double norm(const Point& a) { return a.px * a.px + a.py * a.py; }
long double crs(const Point& a, const Point& b) { return a.px * b.py - a.py * b.px; }
long double abs(const Point& a) { return sqrtl(norm(a)); }
long double dot(const Point& a, const Point& b) { return a.px * b.px + a.py * b.py; }
long double dist(const Point& a, const Point& b) { return abs(b - a); }

int ccw(const Point& p0, const Point& p1, const Point& p2) {
	Point a = p1 - p0, b = p2 - p0;
	if (crs(a, b) > EPS) return 1;
	if (crs(a, b) < -EPS) return -1;
	if (dot(a, b) < -EPS) return 2;
	if (norm(b) - norm(a) > EPS) return -2;
	return 0;
}
Line calc(Line a) {
	//return a;
	if (a.p1 == a.p2) return a;

	Point E = (a.p1 + a.p2); E.px /= 2.0L; E.py /= 2.0L;
	long double ex = a.p2.px - E.px, ey = a.p2.py - E.py;
	long double BAR = 1000.0L / sqrtl(ex * ex + ey * ey);
	ex *= BAR; ey *= BAR;
	return Line{ Point{E.px - ex, E.py - ey}, {E.px + ex, E.py + ey} };
}
Point crp(Line a, Line b) {
	a = calc(a); b = calc(b);
	Point c = b.p2 - b.p1;
	long double d1 = abs(crs(c, a.p1 - b.p1));
	long double d2 = abs(crs(c, a.p2 - b.p1));
	return a.p1 + (a.p2 - a.p1) * (d1 / (d1 + d2));
}
long double area(vector<Point> v) {
	long double ret = 0.0L;
	for (int i = 0; i < v.size(); i++) ret += crs(v[i], v[(i + 1) % v.size()]);
	return ret / 2;
}
int contain(vector<Point> v, Point p) {
	bool in = false;
	for (int i = 0; i < v.size(); ++i) {
		Point a = v[i] - p, b = v[(i + 1) % v.size()] - p;
		if (a.py > b.py) swap(a, b);
		if (a.py <= EPS && EPS < b.py)
			if (crs(a, b) < -EPS) in = !in;
		if (fabs(crs(a, b)) < EPS && dot(a, b) <= EPS) return 1;
	}
	return in ? 2 : 0;
}
vector<Point> convex_hull(vector<Point> v) {
	if (v.size() < 3) return v;
	sort(v.begin(), v.end());
	vector<Point> u = { v[0], v[1] }, l = { v[v.size() - 1], v[v.size() - 2] };
	for (int i = 2; i < v.size(); i++) {
		for (int n = u.size(); n >= 2 && ccw(u[n - 2], u[n - 1], v[i]) >= 0; n--) u.pop_back();
		u.push_back(v[i]);
	}
	for (int i = v.size() - 3; i >= 0; i--) {
		for (int n = l.size(); n >= 2 && ccw(l[n - 2], l[n - 1], v[i]) >= 0; n--) l.pop_back();
		l.push_back(v[i]);
	}
	reverse(l.begin(), l.end());
	for (int i = u.size() - 2; i >= 1; i--) l.push_back(u[i]);
	return l;
}

long double Degree(Line r) {
	long double vx = (r.p2.px - r.p1.px);
	long double vy = (r.p2.py - r.p1.py);
	if (vy < 0) { vy *= -1; vx *= -1; }
	return vx / sqrtl(vx * vx + vy * vy);
}

int N, M; Point C[19], E[19];
vector<Line>A; vector<Point>B, J[19];

void init() {
	for (int i = 0; i < 19; i++) { C[i] = Point{ 0,0 }; E[i] = Point{ 0,0 }; J[i].clear(); }
	B.clear(); A.clear(); N = 0; M = 0;
}

int main() {
	while (true) {
		init();
		cin >> N >> M; if (N == 0 && M == 0) break;
		vector<Point>L;
		for (int i = 0; i < N; i++) { cin >> C[i].px >> C[i].py; L.push_back(C[i]); }
		for (int i = 0; i < M; i++) cin >> E[i].px >> E[i].py;

		for (int i = 0; i < N; i++) A.push_back(Line{ C[i], C[(i + 1) % N] });
		for (int i = 0; i < M; i++) {
			for (int j = i + 1; j < M; j++) {
				Point T = (E[i] + E[j]); T.px /= 2.0L; T.py /= 2.0L;
				double e1 = (E[i].px - T.px), e2 = (E[i].py - T.py);
				Point A1 = Point{ T.px - e2, T.py + e1 };
				Point A2 = Point{ T.px + e2, T.py - e1 };
				A.push_back(Line{ A1, A2 });
			}
		}

		for (int i = 0; i < A.size(); i++) {
			for (int j = i + 1; j < A.size(); j++) {
				long double T1 = Degree(A[i]);
				long double T2 = Degree(A[j]);

				if (fabs(T1 - T2) < EPS) continue;

				Point F = crp(A[i], A[j]);
				if (contain(L, F) >= 1) B.push_back(F);
			}
		}

		sort(B.begin(), B.end());
		B.erase(unique(B.begin(), B.end()), B.end());
		for (int i = 0; i < B.size(); i++) {
			long double maxn = 1e9;
			for (int j = 0; j < M; j++) maxn = min(maxn, dist(E[j], B[i]));

			for (int j = 0; j < M; j++) {
				long double G = dist(E[j], B[i]);
				if (G - maxn < EPS) J[j].push_back(B[i]);
			}
		}

		for (int i = 0; i < M; i++) {
			sort(J[i].begin(), J[i].end());
			J[i].erase(unique(J[i].begin(), J[i].end()), J[i].end());
			vector<Point> U = convex_hull(J[i]);

			long double ans = area(U);
			printf("%.12Lf\n", ans);
		}
	}
	return 0;
}


Measured memory_bytes: 3324