#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
int sig(double r) { return (r < -1e-9) ? -1 : (r > +1e-9) ? +1 : 0; }
struct Pt {
  double x, y;
  Pt() {}
  Pt(double x, double y) : x(x), y(y) {}
  Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
  Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
  Pt operator*(const Pt &a) const {
    return Pt(x * a.x - y * a.y, x * a.y + y * a.x);
  }
  Pt operator-() const { return Pt(-x, -y); }
  Pt operator*(const double &k) const { return Pt(x * k, y * k); }
  Pt operator/(const double &k) const { return Pt(x / k, y / k); }
  double abs() const { return sqrt(x * x + y * y); }
  double abs2() const { return x * x + y * y; }
  double arg() const { return atan2(y, x); }
  double dot(const Pt &a) const { return x * a.x + y * a.y; }
  double det(const Pt &a) const { return x * a.y - y * a.x; }
  bool operator<(const Pt &a) const { return x < a.x || x == a.x && y < a.y; }
  bool operator==(const Pt &a) const { return x == a.x && y == a.y; }
  bool operator!=(const Pt &a) const { return x != a.x || y != a.y; }
};
ostream &operator<<(ostream &os, const Pt &a) {
  os << "(" << a.x << ", " << a.y << ")";
  return os;
}
double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }
int iSP(Pt a, Pt b, Pt c) {
  int s = sig((b - a).det(c - a));
  if (s) return s;
  if (sig((b - a).dot(c - a)) < 0) return -2;
  if (sig((a - b).dot(c - b)) < 0) return +2;
  return 0;
}
int iLL(Pt a, Pt b, Pt c, Pt d) {
  if (sig((b - a).det(d - c))) return 1;
  if (sig((b - a).det(c - a))) return 0;
  return -1;
}
bool iLS(Pt a, Pt b, Pt c, Pt d) {
  return (sig(tri(a, b, c)) * sig(tri(a, b, d)) <= 0);
}
bool iSS(Pt a, Pt b, Pt c, Pt d) {
  return (iSP(a, b, c) * iSP(a, b, d) <= 0 && iSP(c, d, a) * iSP(c, d, b) <= 0);
}
bool iSSstrict(Pt a, Pt b, Pt c, Pt d) {
  return (sig(tri(a, b, c)) * sig(tri(a, b, d)) < 0 &&
          sig(tri(c, d, a)) * sig(tri(c, d, b)) < 0);
}
Pt pLL(Pt a, Pt b, Pt c, Pt d) {
  b = b - a;
  d = d - c;
  return a + b * (c - a).det(d) / b.det(d);
}
double dLP(Pt a, Pt b, Pt c) { return abs(tri(a, b, c)) / (b - a).abs(); }
double dSP(Pt a, Pt b, Pt c) {
  if (sig((b - a).dot(c - a)) <= 0) return (c - a).abs();
  if (sig((a - b).dot(c - b)) <= 0) return (c - b).abs();
  return abs(tri(a, b, c)) / (b - a).abs();
}
double dLL(Pt a, Pt b, Pt c, Pt d) {
  return iLL(a, b, c, d) ? 0 : dLP(a, b, c);
}
double dLS(Pt a, Pt b, Pt c, Pt d) {
  return iLS(a, b, c, d) ? 0 : min(dLP(a, b, c), dLP(a, b, d));
}
double dSS(Pt a, Pt b, Pt c, Pt d) {
  return iSS(a, b, c, d) ? 0
                         : min(min(dSP(a, b, c), dSP(a, b, d)),
                               min(dSP(c, d, a), dSP(c, d, b)));
}
int iCC(Pt a, double r, Pt b, double s) {
  double d = (b - a).abs();
  if (sig(d) == 0 && sig(r - s) == 0) return -1;
  if (sig(r - s - d) > 0) return +2;
  if (sig(s - r - d) > 0) return -2;
  return (sig(r + s - d) >= 0) ? 1 : 0;
}
bool iCS(Pt a, double r, Pt b, Pt c) {
  return (sig(r - dSP(b, c, a)) >= 0 &&
          sig(r - max((b - a).abs(), (c - a).abs())) <= 0);
}
pair<Pt, Pt> pCC(Pt a, double r, Pt b, double s) {
  double d = (b - a).abs();
  double x = (d * d + r * r - s * s) / (d * 2);
  Pt e = (b - a) / d, w = e * Pt(0, 1) * sqrt(max(r * r - x * x, 0.0));
  return make_pair(a + e * x - w, a + e * x + w);
}
pair<Pt, Pt> pCL(Pt a, double r, Pt b, Pt c) {
  Pt h = b + (c - b) * (c - b).dot(a - b) / (c - b).abs2();
  double d = (h - a).abs();
  double y = sqrt(max(r * r - d * d, 0.0));
  Pt e = (c - b) / (c - b).abs();
  return make_pair(h - e * y, h + e * y);
}
pair<Pt, Pt> tCP(Pt a, double r, Pt b) {
  double d2 = (b - a).abs2();
  double x = sqrt(max(d2 - r * r, 0.0));
  Pt h = a + (b - a) * (r * r / d2);
  Pt w = (b - a) * Pt(0, 1) * (x * r / d2);
  return make_pair(h - w, h + w);
}
double aCC(Pt a, double r, Pt b, double s) {
  double d = (a - b).abs();
  if (sig(r - s - d) >= 0) return s * s * PI;
  if (sig(s - r - d) >= 0) return r * r * PI;
  if (sig(r + s - d) <= 0) return 0;
  double x = (d * d + r * r - s * s) / (d * 2);
  double h = sqrt(r * r - x * x);
  return r * r * atan2(h, x) + s * s * atan2(h, d - x) - d * h;
}
int convexHull(int n, Pt p[], Pt q[]) {
  int m = 0, i, r;
  sort(p, p + n);
  for (i = 0; i < n; q[m++] = p[i++])
    for (; m > 1 && sig(tri(q[m - 2], q[m - 1], p[i])) <= 0; --m)
      ;
  for (i = n - 2, r = m; i >= 0; q[m++] = p[i--])
    for (; m > r && sig(tri(q[m - 2], q[m - 1], p[i])) <= 0; --m)
      ;
  return m - 1;
}
int convexCut(int n, Pt p[], Pt a, Pt b, Pt q[]) {
  int m = 0, i;
  p[n] = p[0];
  for (int i = 0; i < (n); i++) {
    if (sig(tri(a, b, p[i])) > 0) q[m++] = p[i];
    if (sig(tri(a, b, p[i])) * sig(tri(a, b, p[i + 1])) < 0)
      q[m++] = pLL(a, b, p[i], p[i + 1]);
  }
  q[m] = q[0];
  return m;
}
int sGP(int n, Pt p[], Pt a) {
  int side = -1, i;
  p[n] = p[0];
  for (i = 0; i < n; ++i) {
    Pt p0 = p[i] - a, p1 = p[i + 1] - a;
    if (sig(p0.det(p1)) == 0 && sig(p0.dot(p1)) <= 0) return 0;
    if (p0.y > p1.y) swap(p0, p1);
    if (sig(p0.y) <= 0 && 0 < sig(p1.y) && sig(p0.det(p1)) > 0) side = -side;
  }
  return side;
}
int sVP(int n, Pt p[], Pt a) {
  Pt o = (p[0] + p[n / 2]) / 2;
  int lo = 0, ho = n, fl = sig(tri(o, p[lo], a));
  p[n] = p[0];
  for (; lo + 1 < ho;) {
    int mo = (lo + ho) / 2, fm = sig(tri(o, p[mo], a));
    (fl - fm - sig(tri(o, p[lo], p[mo])) < 0) ? (lo = mo, fl = fm) : ho = mo;
  }
  return sig(tri(p[lo], p[ho], a));
}
int sAP(Pt a, Pt b, Pt c) {
  return sig(a.det(c)) - sig(b.det(c)) - sig(a.det(b));
}
int N, M;
Pt l[11], c[11];
int main2() {
  for (int i = 0; i < (M); i++) {
    int n = N;
    Pt p[33], q[33];
    for (int j = 0; j < (n); j++) p[j] = l[j];
    for (int j = 0; j < (M); j++)
      if (j != i) {
        Pt mid = (c[i] + c[j]) / 2;
        int m = convexCut(n, p, mid, mid + (c[j] - c[i]) * Pt(0, 1), q);
        n = m;
        for (int i = 0; i < (n); i++) p[i] = q[i];
      }
    double res = 0;
    for (int i = 0; i < (n); i++) res += p[i].det(p[(i + 1) % n]);
    cout << setprecision(16) << res / 2 << endl;
  }
  return 0;
}
int main() {
  while (cin >> N >> M, N) {
    for (int i = 0; i < (N); i++) cin >> l[i].x >> l[i].y;
    for (int i = 0; i < (M); i++) cin >> c[i].x >> c[i].y;
    main2();
  }
}
