Problem: Some of you know an old story of Voronoi Island. There were N liege lords and they are always involved in territorial disputes. The residents of the island were despaired of the disputes.

One day, a clever lord proposed to stop the disputes and divide the island fairly. His idea was to divide the island such that any piece of area belongs to the load of the nearest castle. The method is called Voronoi Division today.

Actually, there are many aspects of whether the method is fair. According to one historian, the clever lord suggested the method because he could gain broader area than other lords.

Your task is to write a program to calculate the size of the area each lord can gain. You may assume that Voronoi Island has a convex shape.



Input

The input consists of multiple datasets. Each dataset has the following format:

N M
Ix1 Iy1
Ix2 Iy2
...
IxN IyN
Cx1 Cy1
Cx2 Cy2
...
CxM CyM


N is the number of the vertices of Voronoi Island; M is the number of the liege lords; (Ixi, Iyi) denotes the coordinate of the i-th vertex; (Cxi, Cyi ) denotes the coordinate of the castle of the i-the lord.

The input meets the following constraints: 3 ≤ N ≤ 10, 2 ≤ M ≤ 10, -100 ≤ Ixi, Iyi, Cxi, Cyi ≤ 100. The vertices are given counterclockwise. All the coordinates are integers.

The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.

Output

For each dataset, print the area gained by each liege lord with an absolute error of at most 10-4 . You may output any number of digits after the decimal point. The order of the output areas must match that of the lords in the input.

Example

Input

3 3
0 0
8 0
0 8
2 2
4 2
2 4
0 0


Output

9.0
11.5
11.5

Solution (in CPP):

Solution:
#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;
}