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;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<int, int>;
const double eps = 1e-8;
const ll MOD = 1000000007;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
template <typename T1, typename T2>
bool chmax(T1 &a, const T2 &b) {
  if(a < b) {a = b; return true;}
  return false;
}
template <typename T1, typename T2>
bool chmin(T1 &a, const T2 &b) {
  if(a > b) {a = b; return true;}
  return false;
}
template<typename T1, typename T2>
ostream& operator<<(ostream &os, const pair<T1, T2> p) {
  os << p.first << ":" << p.second;
  return os;
}
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  for(int i=0;i<((int)(v.size()));++i) {
    if(i) os << " ";
    os << v[i];
  }
  return os;
}
using Real = double;
const Real PI = acos(-1);
using Point = complex<Real>;
namespace std {
  bool operator<(const Point& a, const Point& b) {
    if (a.real() == b.real()) return a.imag() < b.imag();
    return a.real() < b.real();
  }
}
struct Line {
Point a, b;
Line() {}
Line(const Point& a, const Point& b) : a(a), b(b) {}
friend ostream& operator<<(ostream& os, const Line& l) {
  return os << "[" << l.a << "," << l.b << "]";
}
};
struct Segment : Line {
Segment() {}
Segment(const Point& a, const Point& b) : Line(a, b) {}
};
inline bool eq(Real a, Real b) { return abs(b - a) < eps; }
Real radian_to_degree(Real r) {
  return r * 180.0 / PI;
}
Real degree_to_radian(Real d) {
  return d * PI / 180.0;
}
Point rotate(const Point &p, Real theta) {
  return p * polar((Real)1.0, theta);
}
Real cross(const Point& a, const Point& b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
Real dot(const Point& a, const Point& b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
Point projection(const Line& l, const Point& p) {
  Real A = dot(l.b - l.a, p - l.a),
    B = dot(l.a - l.b, p - l.b);
  return (A * l.b + B * l.a) / (A + B);
}
bool parallel(const Line& l1, const Line& l2) {
  return eq(cross(l1.a - l1.b, l2.a - l2.b), 0.0);
}
bool orthogonal(const Line& l1, const Line& l2) {
  return eq(dot(l1.a - l1.b, l2.a - l2.b), 0.0);
}
const int COUNTER_CLOCKWISE = 1,
  CLOCKWISE = -1,
  ONLINE_BACK = 2,
  ONLINE_FRONT = -2,
  ON_SEGMENT = 0;
int ccw(const Point& a, Point b, Point c) {
  b = b - a, c = c - a;
  if (cross(b, c) > eps) return COUNTER_CLOCKWISE;
  if (cross(b, c) < -eps) return CLOCKWISE;
  if (dot(b, c) < 0) return ONLINE_BACK;
  if (norm(b) < norm(c)) return ONLINE_FRONT;
  return ON_SEGMENT;
}
bool intersected(const Line& l, const Point& p) {
  return abs(ccw(l.a, l.b, p)) != 1;
}
bool intersected(const Segment& s, const Point& p) {
  return ccw(s.a, s.b, p) == 0;
}
bool intersected(const Line& l, const Segment& s) {
  return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps;
}
bool intersected(const Segment& s1, const Segment& s2) {
  return ccw(s1.a, s1.b, s2.a) * ccw(s1.a, s1.b, s2.b) <= 0 and
         ccw(s2.a, s2.b, s1.a) * ccw(s2.a, s2.b, s1.b) <= 0;
}
Point crosspoint(const Line& l1, const Line& l2) {
  Real A = cross(l2.a - l1.a, l2.b - l1.a),
    B = cross(l2.b - l1.b, l2.a - l1.b);
  return (A * l1.b + B * l1.a) / (A + B);
}
Real distance(const Line& l, const Point& p) {
  return abs(p - projection(l, p));
}
Real distance(const Segment& s, const Point& p) {
  Point r = projection(s, p);
  if (intersected(s, r)) return abs(r - p);
  return min(abs(s.a - p), abs(s.b - p));
}
Real distance(const Line &l, const Segment &s) {
  if (intersected(l, s)) return 0;
  return min(distance(l, s.a), distance(l, s.b));
}
Real distance(const Segment& s1, const Segment& s2) {
  if (intersected(s1, s2)) return 0.0;
  return min({ distance(s1, s2.a), distance(s1, s2.b),
               distance(s2, s1.a), distance(s2, s1.b) });
}
struct Circle {
Point p;
Real r;
Circle() {}
Circle(const Point& p, Real r) : p(p), r(r) {}
};
int intersected(Circle c1, Circle c2) {
  if (c1.r < c2.r) swap(c1, c2);
  Real d = abs(c1.p - c2.p);
  if (c1.r + c2.r < d) return 4;
  if (eq(c1.r + c2.r, d)) return 3;
  if (c1.r - c2.r < d) return 2;
  if (eq(c1.r - c2.r, d)) return 1;
  return 0;
}
pair<Point,Point> crosspoint(const Circle& c, const Line& l) {
  Real h = distance(l, c.p);
  Point p = projection(l, c.p);
  if (eq(h, c.r)) return { p, p };
  Point u = l.a - l.b; u /= abs(u);
  Real d = sqrt(c.r * c.r - h * h);
  return { p + u * d, p - u * d };
}
pair<Point,Point> crosspoint(const Circle& c1, const Circle& c2) {
  Real d = abs(c2.p - c1.p), t = arg(c2.p - c1.p);
  Real a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  return { c1.p + polar(c1.r, t + a),
           c1.p + polar(c1.r, t - a) };
}
pair<Point,Point> tangent(const Point& p, const Circle& c) {
  return crosspoint(c, Circle(p, sqrt(norm(p - c.p) - c.r * c.r)));
};
vector<Line> common_tangent(const Circle& c1, const Circle& c2) {
  vector<Line> lines;
  Point u = c2.p - c1.p;
  Real d = abs(u);
  if (eq(d, 0.0)) return lines;
  u /= d;
  for (Real s : { -1, 1 }) {
    Real h = (c1.r + s * c2.r) / d;
    if (eq(abs(h), 1.0)) {
      lines.emplace_back(
        c1.p + u * h * c1.r,
        c1.p + u * h * c1.r + rotate(u, PI / 2.0));
    } else if (abs(h) < 1) {
      Real a = acos(h);
      lines.emplace_back(
        c1.p + u * polar(c1.r, a),
        c2.p - s * u * polar(c2.r, a));
      lines.emplace_back(
        c1.p + u * polar(c1.r, -a),
        c2.p - s * u * polar(c2.r, -a));
    }
  }
  return lines;
}
using Polygon = vector<Point>;
Real area(const Polygon& U) {
  Real area = 0;
  for (int i = 0; i < U.size(); ++i) {
    area += cross(U[i], U[(i + 1) % U.size()]);
  }
  return area / 2.0;
}
bool is_convex(const Polygon &U) {
  int n = U.size();
  for (int i = 0; i < n; ++i) {
    if (ccw(U[i], U[(i + 1) % n], U[(i + 2) % n]) == -1) return false;
  }
  return true;
}
const int OUT = 0,
  ON = 1,
  IN = 2;
int contains(const Polygon &U, const Point &p) {
  int in = 0;
  for (int i = 0; i < U.size(); ++i) {
    Point a = U[i] - p, b = U[(i + 1) % U.size()] - p;
    if (cross(a, b) == 0 and dot(a, b) <= 0) return ON;
    if (a.imag() > b.imag()) swap(a, b);
    if (a.imag() <= 0 and 0 < b.imag() and cross(a, b) < 0) in ^= 1;
  }
  return in ? IN : OUT;
}
vector<Point> convex_hull(vector<Point>& p, bool includeOnLine = false) {
  int n = p.size(), k = 0;
  if (n <= 2) return p;
  sort(p.begin(), p.end(), [](Point& a, Point& b) {
    if (a.real() == b.real()) return a.imag() < b.imag();
    return a.real() < b.real();
  });
  vector<Point> ch(n * 2);
  const Real BOUND = includeOnLine ? -eps : eps;
  for (int i = 0; i < n; ch[k++] = p[i++]) {
    while (k >= 2 and cross(ch[k-1] - ch[k-2], p[i] - ch[k-1]) < BOUND) --k;
  }
  for (int i = n-2, t = k+1; i >= 0; ch[k++] = p[i--]) {
    while (k >= t and cross(ch[k-1] - ch[k-2], p[i] - ch[k-1]) < BOUND) --k;
  }
  ch.resize(k-1);
  return ch;
}
Real convex_diameter(const Polygon &U) {
  int n = U.size();
  int is = 0, js = 0;
  for (int i = 1; i < n; ++i) {
    if (U[i].imag() > U[is].imag()) is = i;
    if (U[i].imag() < U[js].imag()) js = i;
  }
  Real maxnorm = norm(U[is] - U[js]);
  int i = is, j = js;
  do {
    if (cross(U[(i+1) % n] - U[i], U[(j+1) % n] - U[j]) >= 0) {
      j = (j+1) % n;
    } else {
      i = (i+1) % n;
    }
    if (norm(U[i] - U[j]) > maxnorm) {
      maxnorm = norm(U[i] - U[j]);
    }
  } while (i != is or j != js);
  return sqrt(maxnorm);
}
Polygon convex_cut(const Polygon& U, const Line& l) {
  Polygon ret;
  for (int i = 0; i < U.size(); ++i) {
    Point now = U[i], nxt = U[(i + 1) % U.size()];
    if (ccw(l.a, l.b, now) != -1) ret.push_back(now);
    if (ccw(l.a, l.b, now) * ccw(l.a, l.b, nxt) == -1) {
      ret.push_back(crosspoint(Line{ now, nxt }, l));
    }
  }
  return ret;
}
bool solve() {
  int n, m; cin >> n >> m;
  if(n == 0) return false;
  Polygon land;
  for(int i=0;i<(n);++i) {
    int x, y; cin >> x >> y;
    land.emplace_back(Point(x, y));
  }
  vector<Point> c;
  for(int i=0;i<(m);++i) {
    int x, y; cin >> x >> y;
    c.emplace_back(Point(x, y));
  }
  double pi = acos(-1);
  vector<double> ans(m);
  for(int i=0;i<(m);++i) {
    Polygon now = land;
    for(int j=0;j<(m);++j) {
      if(i == j) continue;
      Point p = (c[i] + c[j]) / 2.0;
      Point d = (c[j] - c[i]);
      d *= complex<double>(cos(pi/2.0), sin(pi/2.0));
      Line l(p, p+d);
      now = convex_cut(now, l);
    }
    ans[i] = area(now);
  }
  for(int i=0;i<(m);++i) {
    cout << ans[i] << endl;
  }
  return true;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  while(solve()) {}
}