#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-10;
const double INF = 1e12;
struct L : array<complex<double>, 2> {
  L(const complex<double>& a, const complex<double>& b) {
    at(0) = a;
    at(1) = b;
  }
  L() {}
};
namespace std {
bool operator<(const complex<double>& a, const complex<double>& b) {
  return (a.real() != b.real()) ? a.real() < b.real() : a.imag() < b.imag();
}
bool operator==(const complex<double>& a, const complex<double>& b) {
  return abs(a - b) < EPS;
}
}  // namespace std
double dot(complex<double> a, complex<double> b) {
  return (conj(a) * b).real();
}
double cross(complex<double> a, complex<double> b) {
  return (conj(a) * b).imag();
}
int ccw(complex<double> a, complex<double> b, complex<double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > EPS) return +1;
  if (cross(b, c) < -EPS) return -1;
  if (dot(b, c) < -EPS) return +2;
  if (abs(c) - abs(b) > EPS) return -2;
  return 0;
}
bool intersectLS(const L& l, const L& s) {
  return cross(l[1] - l[0], s[0] - l[0]) * cross(l[1] - l[0], s[1] - l[0]) <
         EPS;
}
bool intersectSS(const L& a, const L& b) {
  return (ccw(a[0], a[1], b[0]) * ccw(a[0], a[1], b[1]) <= 0) &&
         (ccw(b[0], b[1], a[0]) * ccw(b[0], b[1], a[1]) <= 0);
}
bool intersectSP(const L& s, const complex<double>& p) {
  return abs(cross(s[0] - p, s[1] - p)) < EPS && dot(s[0] - p, s[1] - p) < EPS;
}
complex<double> projection(const L& l, const complex<double>& p) {
  double t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
  return l[0] + t * (l[0] - l[1]);
}
complex<double> crosspointLL(const L& l, const L& m) {
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  return m[0] + B / A * (m[1] - m[0]);
}
bool isParallel(const complex<double>& a, const complex<double>& b) {
  return abs(cross(a, b)) < EPS;
}
bool isParallel(const L& a, const L& b) {
  return isParallel(a[1] - a[0], b[1] - b[0]);
}
double getarea(const vector<complex<double> >& poly) {
  double ret = 0;
  for (int i = 0; i < (int)poly.size(); i++) {
    ret += cross(poly[i], poly[(i + 1) % poly.size()]);
  }
  return ret * 0.5;
}
int in_poly(const complex<double>& p, const vector<complex<double> >& poly) {
  int n = poly.size();
  int ret = -1;
  for (int i = 0; i < n; i++) {
    complex<double> a = poly[i] - p;
    complex<double> b = poly[(i + 1) % n] - p;
    if (a.imag() > b.imag()) swap(a, b);
    if (intersectSP(L(a, b), complex<double>(0, 0))) return 0;
    if (a.imag() <= 0 && b.imag() > 0 && cross(a, b) < 0) ret = 1 - ret;
  }
  return ret;
}
vector<complex<double> > convex(vector<complex<double> > v) {
  vector<complex<double> > ret;
  sort(v.begin(), v.end());
  v.erase(unique(v.begin(), v.end()), v.end());
  int n = v.size();
  for (int i = 0; i < n; i++) {
    while ((int)ret.size() > 1 &&
           cross(ret.back() - ret[ret.size() - 2], v[i] - ret.back()) < EPS) {
      ret.pop_back();
    }
    ret.push_back(v[i]);
  }
  int t = ret.size();
  for (int i = n - 2; i >= 0; i--) {
    while ((int)ret.size() > t &&
           cross(ret.back() - ret[ret.size() - 2], v[i] - ret.back()) < EPS) {
      ret.pop_back();
    }
    ret.push_back(v[i]);
  }
  if ((int)ret.size() > 1) ret.pop_back();
  return ret;
}
vector<complex<double> > convex_intersect(vector<complex<double> >& a,
                                          vector<complex<double> >& b) {
  vector<complex<double> > plist;
  int n = a.size(), m = b.size();
  for (int r = 0; r < 2; r++) {
    for (int i = 0; i < n; i++) {
      if (in_poly(a[i], b) >= 0) {
        plist.push_back(a[i]);
      }
    }
    swap(n, m);
    swap(a, b);
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      L la(a[i], a[(i + 1) % n]), lb(b[j], b[(j + 1) % m]);
      if (!isParallel(la, lb) && intersectSS(la, lb)) {
        plist.push_back(crosspointLL(la, lb));
      }
    }
  }
  return convex(plist);
}
vector<complex<double> > convex_cut(vector<complex<double> >& v, L l) {
  vector<complex<double> > plist;
  int n = v.size();
  for (int i = 0; i < n; i++) {
    if (ccw(l[0], l[1], v[i]) != -1) {
      plist.push_back(v[i]);
    }
    L e(v[i], v[(i + 1) % n]);
    if (!isParallel(e, l) && intersectLS(l, e)) {
      plist.push_back(crosspointLL(e, l));
    }
  }
  return convex(plist);
}
int main() {
  cout << fixed;
  cout << setprecision(10);
  while (1) {
    int n, m;
    cin >> n >> m;
    if (n == 0) break;
    vector<complex<double> > v(n);
    for (int i = 0; i < n; i++) {
      int x, y;
      cin >> x >> y;
      v[i] = complex<double>(x, y);
    }
    vector<complex<double> > c(m);
    for (int i = 0; i < m; i++) {
      int x, y;
      cin >> x >> y;
      c[i] = complex<double>(x, y);
    }
    if (ccw(v[0], v[1], v[2]) != 1) {
      reverse(v.begin(), v.end());
    }
    for (int i = 0; i < m; i++) {
      vector<complex<double> > poly = v;
      for (int j = 0; j < m; j++) {
        if (i == j) continue;
        complex<double> mid = (c[i] + c[j]) / 2.0;
        L normal(mid, mid + (c[j] - c[i]) * complex<double>(0, 1));
        vector<complex<double> > cut = convex_cut(v, normal);
        poly = convex_intersect(poly, cut);
      }
      cout << getarea(poly) << endl;
    }
  }
  return 0;
}
