#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = MOD + 1;
const long double EPS = 1e-12;
template <class T>
T &chmin(T &a, const T &b) {
  return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
  return a = max(a, b);
}
const long double PI = acos(-1.0);
bool eq(long double a, long double b) { return abs(a - b) < EPS; }
namespace std {
bool operator<(const complex<long double> &a, const complex<long double> &b) {
  return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}  // namespace std
struct Line {
  complex<long double> a, b;
  Line(complex<long double> p, complex<long double> q) : a(p), b(q){};
  Line(long double x1, long double y1, long double x2, long double y2)
      : a(complex<long double>(x1, y1)), b(complex<long double>(x2, y2)){};
};
struct Circle {
  complex<long double> p;
  long double r;
  Circle(complex<long double> a, long double b) : p(a), r(b){};
};
long double dot(complex<long double> a, complex<long double> b) {
  return real(conj(a) * b);
}
long double cross(complex<long double> a, complex<long double> b) {
  return imag(conj(a) * b);
}
int ccw(complex<long double> a, complex<long double> b,
        complex<long double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > EPS) return 1;
  if (cross(b, c) < -EPS) return -1;
  if (dot(b, c) < 0) return 2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
bool isis_ll(Line l, Line m) { return abs(cross(l.b - l.a, m.b - m.a)) > EPS; }
bool isis_ls(Line l, Line s) {
  return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < EPS;
}
bool isis_ss(Line s, Line t) {
  return (ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
          ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0);
}
bool isis_lp(Line l, complex<long double> p) {
  return (abs(cross(l.b - p, l.a - p)) < EPS);
}
bool isis_sp(Line s, complex<long double> p) {
  return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a)) < EPS;
}
complex<long double> projection(Line l, complex<long double> p) {
  complex<long double> base = l.b - l.a;
  long double r = dot(p - l.a, base) / norm(base);
  return l.a + base * r;
}
complex<long double> mirror(Line l, complex<long double> p) {
  return complex<long double>(2, 0) * projection(l, p) - p;
}
long double dist_lp(Line l, complex<long double> p) {
  return abs(p - projection(l, p));
}
long double dist_ll(Line l, Line m) {
  return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}
long double dist_ls(Line l, Line s) {
  if (isis_ls(l, s)) return 0;
  return min(dist_lp(l, s.a), dist_lp(l, s.b));
}
long double dist_sp(Line s, complex<long double> p) {
  complex<long double> r = projection(s, p);
  if (isis_sp(s, r)) return abs(r - p);
  return min(abs(s.a - p), abs(s.b - p));
}
long double dist_ss(Line s, Line t) {
  if (isis_ss(s, t)) return 0;
  return min(min(dist_sp(s, t.a), dist_sp(s, t.b)),
             min(dist_sp(t, s.a), dist_sp(t, s.b)));
}
complex<long double> is_ll(Line s, Line t) {
  long double a = cross(s.b - s.a, t.b - t.a);
  long double b = cross(s.b - s.a, s.b - t.a);
  return t.a + b / a * (t.b - t.a);
}
vector<complex<long double> > is_cc(Circle c1, Circle c2) {
  vector<complex<long double> > res;
  long double d = abs(c1.p - c2.p);
  long double rc = (d * d + pow(c1.r, 2) - pow(c2.r, 2)) / (2 * d);
  long double dfr = pow(c1.r, 2) - rc * rc;
  if (abs(dfr) < EPS) dfr = 0;
  if (dfr < 0.0) return res;
  long double rs = sqrt(dfr);
  complex<long double> diff = (c2.p - c1.p) / d;
  res.push_back(c1.p + diff * complex<long double>(rc, rs));
  if (dfr != 0.0) res.push_back(c1.p + diff * complex<long double>(rc, -rs));
  return res;
}
int isis_cc(Circle c1, Circle c2) {
  long double d = abs(c1.p - c2.p);
  if (d - c1.r - c2.r < -EPS) return -2;
  if (abs(d - c1.r - c2.r) < EPS) return -1;
  if (c1.r < c2.r) swap(c1, c2);
  if (abs(d - c1.r + c2.r) < EPS) return 1;
  if (c1.r - d - c2.r > EPS)
    return 2;
  else
    return 0;
}
bool isis_cl(Circle c, Line l) {
  long double d = dist_lp(l, c.p);
  return d - c.r < -EPS;
}
vector<complex<long double> > is_cl(Circle c, Line l) {
  vector<complex<long double> > res;
  long double d = dist_lp(l, c.p);
  if (d > c.r + EPS) return res;
  long double len = (d > c.r) ? 0 : sqrt(c.r * c.r - d * d);
  complex<long double> nor = (l.a - l.b) / abs(l.a - l.b);
  res.push_back(projection(l, c.p) + len * nor);
  if (abs(len) > EPS) res.push_back(projection(l, c.p - len * nor));
  return res;
}
vector<complex<long double> > is_cs(Circle c, Line s) {
  vector<complex<long double> > v = is_cl(c, s), res;
  for (int i = (0); i < (v.size()); i++) {
    if (ccw(s.a, v[i], s.b) == -2) res.push_back(v[i]);
  }
  return res;
}
vector<Line> tangent_cp(Circle c, complex<long double> p) {
  vector<Line> res;
  complex<long double> v = c.p - p;
  long double d = abs(v);
  long double l = sqrt(norm(v) - c.r * c.r);
  if (isnan(l)) {
    return res;
  }
  complex<long double> v1 = v * complex<long double>(l / d, c.r / d);
  complex<long double> v2 = v * complex<long double>(l / d, -c.r / d);
  res.push_back(Line(p, p + v1));
  if (l < EPS) return res;
  res.push_back(Line(p, p + v2));
  return res;
}
vector<Line> tangent_cc(Circle c1, Circle c2) {
  vector<Line> res;
  if (abs(c1.p - c2.p) - (c1.r + c2.r) > -EPS) {
    complex<long double> center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
    res = tangent_cp(c1, center);
  }
  if (abs(c1.r - c2.r) > EPS) {
    complex<long double> out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
    vector<Line> nres = tangent_cp(c1, out);
    res.insert(res.end(), nres.begin(), nres.end());
  } else {
    complex<long double> v = c2.p - c1.p;
    v /= abs(v);
    complex<long double> q1 = c1.p + v * complex<long double>(0, 1) * c1.r;
    complex<long double> q2 = c1.p + v * complex<long double>(0, -1) * c1.r;
    res.push_back(Line(q1, q1 + v));
    res.push_back(Line(q2, q2 + v));
  }
  return res;
}
vector<complex<long double> > ConvexCut(const vector<complex<long double> > &g,
                                        const Line l) {
  vector<complex<long double> > res;
  for (int i = (0); i < (g.size()); i++) {
    complex<long double> a = g[i], b = g[(i + 1) % g.size()];
    if (ccw(l.a, l.b, a) != -1) res.push_back(a);
    if (ccw(l.a, l.b, a) * ccw(l.a, l.b, b) < 0)
      res.push_back(is_ll(Line(a, b), l));
  }
  return res;
}
vector<Line> sui(complex<long double> a, complex<long double> b) {
  complex<long double> m = (a + b) / complex<long double>(2, 0);
  complex<long double> v = b - a;
  complex<long double> n1(v.imag(), -v.real()), n2(-v.imag(), v.real());
  vector<Line> res = {Line(m, m + n1), Line(m, m + n2)};
  return res;
}
long double area(const vector<complex<long double> > &p) {
  long double res = 0;
  for (int i = (0); i < (p.size()); i++) {
    res += cross(p[i], p[(i + 1) % p.size()]);
  }
  return res / 2;
}
int main() {
  int n, m;
  cin >> n >> m;
  vector<complex<long double> > g;
  for (int i = (0); i < (n); i++) {
    long double x, y;
    cin >> x >> y;
    g.emplace_back(x, y);
  }
  vector<complex<long double> > ps;
  for (int i = (0); i < (m); i++) {
    long double x, y;
    cin >> x >> y;
    ps.emplace_back(x, y);
  }
  for (int i = (0); i < (m); i++) {
    vector<complex<long double> > tmp = g;
    for (int j = (0); j < (m); j++) {
      if (i == j) continue;
      vector<Line> ls = sui(ps[i], ps[j]);
      if (ccw(ls[0].a, ls[0].b, ps[i]) == 1)
        tmp = ConvexCut(tmp, ls[0]);
      else
        tmp = ConvexCut(tmp, ls[1]);
    }
    cout << fixed << setprecision(10) << area(tmp) << endl;
  }
  return 0;
}
