#include <bits/stdc++.h>
using namespace std;

typedef complex<double> P;

const double eps = 1e-8;

bool equals(double a, double b) {
  return abs(a-b) < eps;
}

double cross(P a, P b) {
  return a.real()*b.imag() - a.imag()*b.real();
}

double dot(P a, P b) {
  return a.real()*b.real() + a.imag()*b.imag();
}

int ccw(P p, P a, P b) {
  a -= p;
  b -= p;
  if(cross(a, b) > eps) return 1;
  if(cross(a, b) < -eps) return -1;
  if(dot(a, b) < -eps) return 2;
  if(norm(b) - norm(a) > eps) return -2;
  return 0;
}

P getCrossP(P a1, P a2, P b1, P b2) {
  P a = a2 - a1;
  P b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}

vector<P> convex_cut(vector<P> ps, P p1, P p2, int dir = -1) {
  vector<P> v;
  for(int i = 0; i < ps.size(); ++i) {
    P a = ps[i];
    P b = ps[(i+1)%ps.size()];
    if(ccw(p1, p2, a) != dir) v.push_back(a);
    if(ccw(p1, p2, a)*ccw(p1, p2, b) == -1)
      v.push_back(getCrossP(a, b, p1, p2));
  }
  return v;
}

double getArea(const vector<P> &ps) {
  int n = ps.size();
  double res = 0;
  for(int i = 0; i < n; ++i) {
    res += cross(ps[i], ps[(i+1)%n]);
  }
  return res / 2.0;
}


int main() {
  for(int N, M; cin >> N >> M && (N|M); ) {
    vector<P> ps(N);
    for(int i = 0; i < N; ++i) {
      cin >> ps[i].real() >> ps[i].imag();
    }
    if(getArea(ps) < 0.0) reverse(ps.begin(), ps.end());
    vector<P> C(N);
    for(int j = 0; j < M; ++j) {
      cin >> C[j].real() >> C[j].imag();
    }


    for(int i = 0; i < M; ++i) {
      vector<P> g = ps;
      for(int j = 0; j < M; ++j) {
	if(i == j) continue;
	P p1, p2, base, base2;
	base = C[j] - C[i];
	base2 = P(-base.imag(), base.real());
	p1 = (C[i] + C[j]) / 2.0;
	p2 = p1 + base2;
	g = convex_cut(g, p1, p2);
      }
      printf("%.10f\n", getArea(g));
    }

  }
  return 0;
}