#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T begin, T end) {
  for (T i = begin; i != end; ++i) cerr << *i << " ";
  cerr << endl;
}
inline bool valid(int x, int y, int W, int H) {
  return (x >= 0 && y >= 0 && x < W && y < H);
}
const int INF = 100000000;
const double EPS = 1e-5;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int sign(double r) { return (r < -EPS) ? -1 : (r > EPS) ? 1 : 0; }
bool eq(double a, double b) { return abs(b - a) < EPS; }
struct Point {
  double x, y;
  Point() {}
  Point(double x, double y) : x(x), y(y) {}
  Point operator+(const Point& b) const { return Point(x + b.x, y + b.y); }
  Point operator-(const Point& b) const { return Point(x - b.x, y - b.y); }
  Point operator*(const double b) const { return Point(x * b, y * b); }
  Point operator*(const Point& b) const {
    return Point(x * b.x - y * b.y, x * b.y + y * b.x);
  }
  Point operator/(const double b) const { return Point(x / b, y / b); }
  bool operator<(const Point& b) const { return x != b.x ? x < b.x : y < b.y; }
  bool operator==(const Point& b) const { return eq(x, b.x) && eq(y, b.y); }
  double norm() { return x * x + y * y; }
  double arg() { return atan2(x, y); }
  double abs() { return sqrt(norm()); }
  Point rotate(double theta) {
    return Point(cos(theta) * x - sin(theta) * y,
                 sin(theta) * x + cos(theta) * y);
  }
  Point rotate90() { return Point(-y, x); }
};
ostream& operator<<(ostream& os, Point& p) {
  return os << "(" << p.x << "," << p.y << ")";
}
istream& operator>>(istream& is, Point& a) { return is >> a.x >> a.y; }
double dot(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; }
double cross(const Point& a, const Point& b) { return a.x * b.y - a.y * b.x; }
Point polor(double rho, double theta) {
  return Point(rho * cos(theta), rho * sin(theta));
}
struct Line : public vector<Point> {
  Line(const Point& a, const Point& b) {
    push_back(a);
    push_back(b);
  }
  Point vector() const { return back() - front(); }
};
struct Circle : Point {
  double r;
  Circle(Point p, double r) : Point(p), r(r) {}
};
Point curr(const vector<Point>& a, int x) { return a[x]; }
Point next(const vector<Point>& a, int x) { return a[(x + 1) % a.size()]; }
Point prev(const vector<Point>& a, int x) {
  return a[(x - 1 + a.size()) % a.size()];
}
int ccw(Point a, Point b, Point c) {
  b = b - a;
  c = c - a;
  if (cross(b, c) > EPS) return +1;
  if (cross(b, c) < -EPS) return -1;
  if (dot(b, c) < 0) return +2;
  if (b.norm() < c.norm()) return -2;
  return 0;
}
bool intersectLL(const Line& l, const Line& m) {
  return abs(cross(l.vector(), m[1] - m[0])) > EPS ||
         abs(cross(l.vector(), m[0] - l[0])) < EPS;
}
bool intersectLS(const Line& l, const Line& s) {
  return cross(l.vector(), s[0] - l[0]) * cross(l.vector(), s[1] - l[0]) < EPS;
}
bool intersectLP(const Line& l, const Point& p) {
  return abs(ccw(l[0], l[1], p)) != 1;
}
bool intersectSS(const Line& s, const Line& t) {
  return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
         ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool intersectSP(const Line& s, const Point& p) {
  return ccw(s[0], s[1], p) == 0;
}
bool intersectCP(const Circle& c, const Point& p) {
  return (c - p).abs() < c.r + EPS;
}
bool intersectCC(const Circle& c, const Circle& d) {
  return (c - d).abs() < c.r + d.r + EPS &&
         (c - d).abs() > abs(c.r - d.r) - EPS;
}
Point projection(const Line& l, const Point& p) {
  double t = dot(p - l[0], l.vector()) / l.vector().norm();
  return l[0] + l.vector() * t;
}
Point reflection(const Line& l, const Point& p) {
  return p + (projection(l, p) - p) * 2;
}
double distanceLP(const Line& l, const Point& p) {
  return (p - projection(l, p)).abs();
}
double distanceLL(const Line& l, const Line& m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const Line& l, const Line& s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const Line& s, const Point& p) {
  const Point r = projection(s, p);
  if (intersectSP(s, r)) return (r - p).abs();
  return min((s[0] - p).abs(), (s[1] - p).abs());
}
double distanceSS(const Line& s, const Line& t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
Point crosspointLL(const Line& l, const Line& m) {
  double d = cross(m.vector(), l.vector());
  if (abs(d) < EPS) assert(false);
  return l[0] + l.vector() * cross(m.vector(), m[1] - l[0]) * (1.0 / d);
}
vector<Point> convex_cut(const vector<Point>& P, const Line& l) {
  vector<Point> Q;
  for (int i = (0); i < (int)(P.size()); ++i) {
    Point A = curr(P, i), B = next(P, i);
    if (ccw(l[0], l[1], A) != -1) Q.push_back(A);
    if (intersectLS(l, Line(A, B))) Q.push_back(crosspointLL(l, Line(A, B)));
  }
  return Q;
}
Line median(const Point& a, const Point& b) {
  Point mid((a.x + b.x) / 2.0, (a.y + b.y) / 2.0);
  Point vec = (mid - a).rotate90();
  return Line(mid, mid + vec);
}
double area(const vector<Point>& P) {
  double A = 0;
  for (int i = (0); i < (int)(P.size()); ++i) {
    A += cross(curr(P, i), next(P, i));
  }
  return A / 2.0;
}
int main() {
  int N, M;
  while (cin >> N >> M) {
    vector<Point> island(N);
    for (int i = (0); i < (int)(N); ++i) cin >> island[i];
    vector<Point> castle(M);
    for (int i = (0); i < (int)(M); ++i) cin >> castle[i];
    for (int i = (0); i < (int)(M); ++i) {
      vector<Point> land = island;
      for (int j = (0); j < (int)(M); ++j)
        if (i != j) {
          land = convex_cut(land, median(castle[i], castle[j]));
        }
      printf("%.6lf\n", area(land));
    }
  }
  return 0;
}
