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 <bits/stdc++.h>

using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;

#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back

const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 1000000007;

template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
  out<<'('<<a.first<<','<<a.second<<')';
  return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
  out<<'[';
  REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
  out<<']';
  return out;
}

int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};

const double EPS = 1e-8;

using R = long double;
using P = complex<R>;
using L = pair<P,P>;
using G = vector<P>;
struct C {
  P c; R r;
  C() {}
  C(const P &a, const R &b) : c(a), r(b) {}
};
struct S : public L {
  S() {}
  S(const P &a, const P &b) : L(a,b) {}
};

inline int sgn(const R& r) { return (r>EPS) - (r<-EPS); }
inline R dot(const P& a, const P& b) {
  return real(a)*real(b) + imag(a)*imag(b);
}
inline R det(const P& a, const P& b) {
  return real(a)*imag(b) - imag(a)*real(b);
}
inline P vec(const L& l) {return l.second - l.first;}
namespace std {
	bool operator < (const P& a, const P& b) {
		return sgn(real(a-b)) ? real(a-b) < 0 : sgn(imag(a-b)) < 0;
	}
	bool operator == (const P& a, const P& b) {
		return sgn(real(a-b)) == 0 && sgn(imag(a-b)) == 0;
	}
  bool cmp_y (const P& a, const P& b) {
    return sgn(imag(a-b)) ? imag(a-b) < 0 : sgn(real(a-b)) < 0;
  }
}

// P,L,Sについて入力
inline istream& operator>>(istream& is, P& p) {
  R x, y;
  is >> x >> y;
  p = P(x, y);
  return is;
}
inline istream& operator>>(istream& is, L& l) {
  P a, b;
  is >> a >> b;
  l = L(a, b);
  return is;
}
inline istream& operator>>(istream& is, S& s) {
  P a, b;
  is >> a >> b;
  s = S(a, b);
  return is;
}

// 射影
P inline projection(const L &l, const P &p) {
  R t = dot(p-l.first, l.first-l.second) / norm(l.first-l.second);
  return l.first + t*(l.first-l.second);
}
// 反射
P inline reflection(const L &l, const P &p) {
  return p + (R)2 * (projection(l, p) - p);
}

// 線分abから見たcの位置
enum CCW{LEFT=1, RIGHT=2, BACK=4, FRONT=8, ON_SEG=16};
int ccw(P a, P b, P c) {
	P p = (c-a)/(b-a);
	if(sgn(imag(p)) > 0) return LEFT;
	if(sgn(imag(p)) < 0) return RIGHT;
	if(sgn(real(p)) < 0) return BACK;
	if(sgn(real(p)-1) > 0) return FRONT;
	return ON_SEG;
}

// 垂直,平行
inline bool vertical(L a, L b) {return sgn(dot(vec(a), vec(b))) == 0;}
inline bool parallel(L a, L b) {return sgn(det(vec(a), vec(b))) == 0;}
inline bool eal(L a, L b) {return vertical(a,b) && parallel(a,b);}

// 交差判定
template<bool strict=false> inline bool intersect(const L&l1, const L&l2) {
  if(strict) return sgn(det(vec(l1),vec(l2))) != 0;
  return sgn(det(vec(l1),vec(l2))) != 0 || l1 == l2;
}
template<bool strict=false> inline bool intersect(const L&l, const S&s) {
  if(strict) det(s.first, vec(l)) * det(s.second, vec(l)) < 0;
  return det(s.first, vec(l)) * det(s.second, vec(l)) <= 0;
}
template<bool strict=false> inline bool intersect(const S&s1, const S&s2) {
  int ccw1 = ccw(s1.first, s1.second, s2.first) | ccw(s1.first, s1.second, s2.second);
  int ccw2 = ccw(s2.first, s2.second, s1.first) | ccw(s2.first, s2.second, s1.second);
  if(strict) return (ccw1 & ccw2) == (LEFT | RIGHT);
  return (ccw1 & ccw2) == (LEFT | RIGHT) || ((ccw1 | ccw2) & ON_SEG);
}
template<bool strict=false> inline bool intersect(const S&s, const P&p) {
  return ccw(s.first, s.second, p) == ON_SEG;
}
template<bool strict=false> inline bool intersect(const L&l, const P&p) {
  return ccw(l.first, l.second, p) == ON_SEG ||
          ccw(l.first, l.second, p) == FRONT ||
          ccw(l.first, l.second, p) == BACK;
}
int intersect(const C& a, const C& b) {
	R dist = sqrt(norm(a.c-b.c)), r1 = a.r + b.r, r2 = abs(a.r - b.r);
	if(sgn(r1-dist) < 0)  return 4;	// 円が離れている
	if(sgn(r1-dist) == 0) return 3;	// 外接
	if(sgn(r2-dist) < 0 && sgn(dist-r1) < 0) return 2; // 交差
	if(sgn(dist-r2) == 0) return 1; // 内接
	return 0;	// 内部に含む
}

// 距離
R dist(const S& s, const P& p) {
  P q = projection(s, p);
  if(sgn(dot(s.second-s.first, p-s.first)) <= 0) q = s.first;
  if(sgn(dot(s.first-s.second, p-s.second)) <= 0) q = s.second;
  return abs(p-q);
}
R dist(const S& a, const S& b) {
  if(intersect(a, b)) return 0;
  return min({dist(a, b.first), dist(a, b.second), dist(b, a.first), dist(b, a.second)});
}
R dist(const L& l, const P& p) {
  P q = projection(l, p);
  return abs(p-q);
}

// 交点 交差判定を先にすること!!!
inline P crosspoint(const L& l1, const L& l2) {
  R ratio = det(vec(l2), l2.first-l1.first)/det(vec(l2),vec(l1));
  return l1.first + vec(l1)*ratio;
}
vector<P> crosspoint(C c, L l) {
	R d = dist(l, c.c), r = c.r;
	P m = projection(l, c.c);
	P x = sqrt(r*r-d*d)*vec(l)/abs(vec(l));
	vector<P> ret(2,m);
	ret[0] -= x; ret[1] += x;
	if(ret[1] < ret[0]) swap(ret[0], ret[1]);
	return ret;
}
vector<P> crosspoint(C a, C b) {
	R d = abs(a.c-b.c);
	R t = (a.r*a.r-b.r*b.r+d*d)/2/d, h = sqrt(a.r*a.r-t*t);
	P m = t/abs(b.c-a.c)*(b.c-a.c)+a.c;
  auto n_vector = [&](P p) -> P { return P(-p.imag(), p.real())/abs(p); };
	P n = n_vector(a.c-b.c);
	vector<P> ret(2, m);
	ret[0] -= h*n; ret[1] += h*n;
	if(ret[1] < ret[0]) swap(ret[0], ret[1]);
	return ret;
}

// 面積 頂点が反時計回りに並んでいること
R area(const G& pol) {
  R ret = 0.0;
  REP(i, pol.size()) ret += det(pol[i], pol[(i+1)%pol.size()]);
  return (ret/2.0);
}

// 凸性の判定
bool isConvex(const G& pol) {
  REP(i, pol.size()) {
    if(sgn(det(pol[(i+1)%pol.size()]-pol[i], pol[(i+2)%pol.size()]-pol[i])) < 0) {
      return false;
    }
  }
  return true;
}

// 多角形と点の内包
// 2→in 1→on 0→out
int inPolygon(const G& pol, const P& p) {
  bool in = false;
  for (int i = 0; i < pol.size(); ++i) {
  	P a = pol[i] - p, b = pol[(i+1)%pol.size()] - p;
    if (imag(a) > imag(b)) swap(a, b);
    if (imag(a) <= 0 && 0 < imag(b) && sgn(det(a, b)) < 0) {
      in = !in;
    }
    if (sgn(det(a, b)) == 0 && sgn(dot(a, b)) <= 0) return 1;
  }
  return in ? 2 : 0;
}

// 凸包 3点が一直線上に並ぶときに注意
// 凸包のうち一番左にある頂点の中で一番下の頂点から時計回り
G convex_hull(G ps) {
  int n = ps.size(), k = 0;
  sort(ps.begin(), ps.end());
  G r(2*n);
  for(int i=0; i<n; i++){
    while(k>1 && sgn(det(r[k-1]-r[k-2], ps[i]-r[k-2])) < 0) k--;
    r[k++] = ps[i];
  }
  for(int i=n-2,t=k; i>=0; i--){
    while(k>t && sgn(det(r[k-1]-r[k-2], ps[i]-r[k-2])) < 0) k--;
    r[k++] = ps[i];
  }
  r.resize(k-1);
  return r;
}

// 3点が与えられたときに円を求める
// 3点が直線上に並んでいるときは{0, 0, -1}を返す
// ToDo:見直す
C calcCircle(R x1, R y1, R x2, R y2, R x3, R y3) {
  R a = x2-x1, b = y2-y1, c = x3-x1, d = y3-y1;
  if ((sgn(a) && sgn(d)) || (sgn(b) && sgn(c))) {
    R ox = x1+(d*(a*a+b*b)-b*(c*c+d*d))/(a*d-b*c)/2, oy;
    if (b) oy = (a*(x1+x2-ox-ox) + b*(y1+y2)) / b/2;
    else oy = (c*(x1+x3-ox-ox) + d*(y1+y3)) / d/2;
    R r1 = sqrt((ox-x1) * (ox-x1) + (oy-y1) * (oy-y1)),
      r2 = sqrt((ox-x2) * (ox-x2) + (oy-y2) * (oy-y2)),
      r3 = sqrt((ox-x3) * (ox-x3) + (oy-y3) * (oy-y3)),
      r = (r1+r2+r3) / 3;
    return {P{ox, oy}, r};
  }
  return {P{0, 0}, -1};
}

// 2点p1, p2を通り、半径がrの円を2つ返す
vector<C> calcCircle(P p1, P p2, R r) {
	// 存在しない
	if(abs(p1-p2) > 2*r) return {};
	P p3 = {(p1.real()+p2.real())/2, (p1.imag()+p2.imag())/2};
	R l = abs(p1-p3);
	P p1p2 = p2-p1;
	R a = p1p2.real(), b = p1p2.imag();
	R dx1 = b*sqrt((r*r-l*l)/(a*a+b*b)), dy1 = a*sqrt((r*r-l*l)/(a*a+b*b));
	return {{{p3.real()+dx1, p3.imag()-dy1}, r}, {{p3.real()-dx1, p3.imag()+dy1}, r}};
}

G convex_cut(const G& pol, const L& l) {
  G res;
  REP(i, pol.size()) {
    P a = pol[i], b = pol[(i + 1)%pol.size()];
    int da = sgn(det(l.first-a, l.second-a)), db = sgn(det(l.first-b, l.second-b));
    if (da >= 0) res.emplace_back(a);
    if (da * db < 0) res.emplace_back(crosspoint(L{a, b}, l));
  }
  return res;
}

// -----ボロノイ図-----
// 1直線上に3点が並んでるような部分を消去 O(p.size())
G normalize_poligon(G p) {
  int n = p.size();
  REP(i, p.size()) {
    if(ccw(p[(i+n-1)%n], p[i], p[(i+1)%n]) == ON_SEG) {
      p.erase(p.begin() + i);
      i--;
    }
  }
  return p;
}
// 点a,bの垂直二等分線 O(1)
L bisector(P a, P b) {
  const P mid = (a + b) / P(2, 0);
  return L{mid, mid + (b - a)*P(0, 1)};
}
// 多角形polと点集合vについてボロノイ図を計算
// 点v[s]が属する部分を返す O(pol.size * v.size())
G voronoi_cell(G pol, G v, int s) {
  pol = normalize_poligon(pol);
  REP(i, v.size()) if(i != s) {
    pol = convex_cut(pol, bisector(v[s], v[i]));
  }
  return pol;
}
//-----ボロノイ図ここまで-----

signed main(void)
{
  cin.tie(0);
  ios::sync_with_stdio(false);

  while(1) {
    int n, m;
    cin >> n >> m;
    if(!n && !m) break;
    G island(n), lord(m);
    REP(i, n) cin >> island[i];
    REP(i, m) cin >> lord[i];

    REP(i, m) {
      G pol = voronoi_cell(island, lord, i);
      cout << fixed << setprecision(15) << area(pol) << endl;
    }
  }

  return 0;
}