#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
  for (int i = 0; i < (v.size()); i++) {
    os << v[i] << (i == v.size() - 1 ? "" : " ");
  }
  return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
  for (T& x : v) {
    is >> x;
  }
  return is;
}
struct Segment {
  complex<double> p1, p2;
  Segment(complex<double> p1 = complex<double>(),
          complex<double> p2 = complex<double>())
      : p1(p1), p2(p2) {}
};
typedef Segment Line;
typedef vector<complex<double> > Polygon;
namespace std {
bool operator<(const complex<double>& a, const complex<double>& b) {
  return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
bool operator==(const complex<double>& a, const complex<double>& b) {
  return a.real() == b.real() && a.imag() == b.imag();
}
}  // namespace std
class Circle {
 public:
  complex<double> p;
  double r;
  Circle(complex<double> p = complex<double>(), double r = 0.0) : p(p), r(r) {}
};
int ccw(complex<double>, complex<double>, complex<double>);
bool EQ(double a, double b) { return (abs(a - b) < (1e-10)); }
bool EQV(complex<double> a, complex<double> b) {
  return (EQ(a.real(), b.real()) && EQ(a.imag(), b.imag()));
}
double dot(complex<double> a, complex<double> b) {
  return (a.real() * b.real() + a.imag() * b.imag());
}
double cross(complex<double> a, complex<double> b) {
  return (a.real() * b.imag() - a.imag() * b.real());
}
bool isOrthogonal(complex<double> a1, complex<double> a2, complex<double> b1,
                  complex<double> b2) {
  return EQ(dot(a1 - a2, b1 - b2), 0.0);
}
bool isOrthogonal(Line s1, Line s2) {
  return isOrthogonal(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool isParallel(complex<double> a1, complex<double> a2, complex<double> b1,
                complex<double> b2) {
  return EQ(cross(a1 - a2, b1 - b2), 0.0);
}
bool isParallel(Line s1, Line s2) {
  return isParallel(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool isPointOnLine(complex<double> a, complex<double> b, complex<double> c) {
  return EQ(cross(b - a, c - a), 0.0);
}
bool isPointOnLine(Line s, complex<double> c) {
  return isPointOnLine(s.p1, s.p2, c);
}
double distanceLPoint(complex<double> a, complex<double> b, complex<double> c) {
  return abs(cross(b - a, c - a)) / abs(b - a);
}
double distanceLPoint(Line s, complex<double> c) {
  return distanceLPoint(s.p1, s.p2, c);
}
double distanceLsPoint(complex<double> a, complex<double> b,
                       complex<double> c) {
  if (dot(b - a, c - a) < (1e-10)) return abs(c - a);
  if (dot(a - b, c - b) < (1e-10)) return abs(c - b);
  return abs(cross(b - a, c - a)) / abs(b - a);
}
double distanceLsPoint(Segment s, complex<double> c) {
  return distanceLsPoint(s.p1, s.p2, c);
}
bool isIntersectedLs(complex<double> a1, complex<double> a2, complex<double> b1,
                     complex<double> b2) {
  return (ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 &&
          ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0);
}
bool isIntersectedLs(Segment s1, Segment s2) {
  return isIntersectedLs(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool isContainSamePoints(Segment s1, Segment s2) {
  if (abs(s1.p1 - s2.p1) < (1e-10)) return true;
  if (abs(s1.p1 - s2.p2) < (1e-10)) return true;
  if (abs(s1.p2 - s2.p1) < (1e-10)) return true;
  if (abs(s1.p2 - s2.p2) < (1e-10)) return true;
  return false;
}
complex<double> intersectionLs(complex<double> a1, complex<double> a2,
                               complex<double> b1, complex<double> b2) {
  complex<double> base = b2 - b1;
  double d1 = abs(cross(base, a1 - b1));
  double d2 = abs(cross(base, a2 - b1));
  double t = d1 / (d1 + d2);
  return complex<double>(a1 + (a2 - a1) * t);
}
complex<double> intersectionLs(Segment s1, Segment s2) {
  return intersectionLs(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool isIntersectedL(complex<double> a1, complex<double> a2, complex<double> b1,
                    complex<double> b2) {
  return !EQ(cross(a1 - a2, b1 - b2), 0.0);
}
bool isIntersectedL(Line l1, Line l2) {
  return isIntersectedL(l1.p1, l1.p2, l2.p1, l2.p2);
}
complex<double> intersectionL(complex<double> a1, complex<double> a2,
                              complex<double> b1, complex<double> b2) {
  complex<double> a = a2 - a1;
  complex<double> b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}
complex<double> intersectionL(Line l1, Line l2) {
  return intersectionL(l1.p1, l1.p2, l2.p1, l2.p2);
}
double distanceLL(Segment s1, Segment s2) {
  if (isIntersectedLs(s1.p1, s1.p2, s2.p1, s2.p2)) return 0.0;
  return min(min(distanceLsPoint(s1.p1, s1.p2, s2.p1),
                 distanceLsPoint(s1.p1, s1.p2, s2.p2)),
             min(distanceLsPoint(s2.p1, s2.p2, s1.p1),
                 distanceLsPoint(s2.p1, s2.p2, s1.p2)));
}
double distanceLL(complex<double> p0, complex<double> p1, complex<double> p2,
                  complex<double> p3) {
  Segment s1 = Segment{p0, p1}, s2 = Segment{p2, p3};
  return distanceLL(s1, s2);
}
complex<double> project(Segment s, complex<double> p) {
  complex<double> base = s.p2 - s.p1;
  double r = dot(p - s.p1, base) / norm(base);
  return complex<double>(s.p1 + base * r);
}
complex<double> reflect(Segment s, complex<double> p) {
  return complex<double>(p + (project(s, p) - p) * 2.0);
}
complex<double> rotation(complex<double> p, double angle) {
  double x, y;
  x = p.real() * cos(angle) - p.imag() * sin(angle);
  y = p.real() * sin(angle) + p.imag() * cos(angle);
  return complex<double>(x, y);
}
pair<complex<double>, complex<double> > getCrossPoints(Circle c, Line l) {
  complex<double> pr = project(l, c.p);
  complex<double> e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
  double base = sqrt(c.r * c.r - norm(pr - c.p));
  return make_pair(pr + e * base, pr - e * base);
}
double arg(complex<double> p) { return atan2(p.imag(), p.real()); }
complex<double> polar(double a, double r) {
  return complex<double>(cos(r) * a, sin(r) * a);
}
pair<complex<double>, complex<double> > getCrossPoints(Circle c1, Circle c2) {
  double d = abs(c1.p - c2.p);
  double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  double t = arg(c2.p - c1.p);
  return make_pair(complex<double>(c1.p + polar(c1.r, t + a)),
                   complex<double>(c1.p + polar(c1.r, t - a)));
}
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
int ccw(complex<double> p0, complex<double> p1, complex<double> p2) {
  complex<double> a = p1 - p0;
  complex<double> b = p2 - p0;
  if (cross(a, b) > (1e-10)) return COUNTER_CLOCKWISE;
  if (cross(a, b) < -(1e-10)) return CLOCKWISE;
  if (dot(a, b) < -(1e-10)) return ONLINE_BACK;
  if (abs(a) < abs(b)) return ONLINE_FRONT;
  return ON_SEGMENT;
}
complex<double> getCrossPointLL(Line a, Line b) {
  double A = cross(a.p2 - a.p1, b.p2 - b.p1);
  double B = cross(a.p2 - a.p1, a.p2 - b.p1);
  if (abs(A) < (1e-10) && abs(B) < (1e-10)) return b.p1;
  return b.p1 + (b.p2 - b.p1) * (B / A);
}
Polygon convexCut(Polygon p, Line l) {
  Polygon q;
  for (int i = 0; i < (p.size()); i++) {
    complex<double> a = p[i], b = p[(i + 1) % p.size()];
    if (ccw(l.p1, l.p2, a) != -1) q.emplace_back(a);
    if (ccw(l.p1, l.p2, a) * ccw(l.p1, l.p2, b) < 0) {
      q.emplace_back(getCrossPointLL(Line{a, b}, l));
    }
  }
  return q;
}
Line bisector(complex<double> a, complex<double> b) {
  complex<double> A = (a + b) * complex<double>(0.5, 0);
  return Line(A, A + (b - a) * complex<double>(0, M_PI / 2));
}
Polygon voronoiCell(Polygon g, vector<complex<double> > v, int s) {
  for (int i = 0; i < (v.size()); i++) {
    if (i != s) g = convexCut(g, bisector(v[s], v[i]));
  }
  return g;
}
double areaOfTriangle(complex<double> a, complex<double> b, complex<double> c) {
  double w, x, y, z;
  w = b.real() - a.real();
  x = b.imag() - a.imag();
  y = c.real() - a.real();
  z = c.imag() - a.imag();
  return abs((w * z - x * y) / 2);
}
double areaOfPolygon(Polygon g) {
  int n = g.size();
  double ret = 0.0;
  for (int i = 0; i < (n); i++) ret += cross(g[i], g[(i + 1) % n]);
  return abs(ret) / 2.0;
}
int main() {
  int n, m;
  while (cin >> n >> m, n) {
    Polygon g(n);
    for (int i = 0; i < (n); i++) {
      double a, b;
      cin >> a >> b;
      g[i] = complex<double>(a, b);
    }
    vector<complex<double> > v(m);
    for (int i = 0; i < (m); i++) {
      double a, b;
      cin >> a >> b;
      v[i] = complex<double>(a, b);
    }
    for (int i = 0; i < (n); i++) {
      cout << fixed << setprecision(10) << areaOfPolygon(voronoiCell(g, v, i))
           << endl;
    }
  }
}
