#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <assert.h>
#include <array>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <numeric>
#include <bitset>
#include <fstream>

using namespace std;

#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }

typedef long long ll;
int const inf = 1<<29;
double const EPS = 1e-7;

typedef complex<double> P;

double dot(P a, P b) { return real(conj(a)*b); }
double cross(P a, P b) { return imag(conj(a)*b); }

int ccw(P p0, P p1, P p2) {
  auto a = p1 - p0;
  auto b = p2 - p0;
  if(cross(a, b) > EPS) return +1;
  if(cross(a, b) < -EPS) return -1;
  if(dot(a, b) < -EPS) return +2;
  if(norm(a) < norm(b)) return -2;
  return 0;
}

double area(vector<P> &g) {
  double ret = 0;
  rep(i, g.size()) {
    ret += cross(g[i], g[(i+1)%g.size()]);
  }
  return abs(ret) / 2.0;
}

struct Line: public vector<P> {
  Line(P a, P b) {
    push_back(a), push_back(b);
  }
};

Line perpendicular_bisector(P& a, P& b) {
  P c = (a + b) / 2.0;
  P p = P(c.real() + (a.imag() - b.imag()), c.imag() - (a.real() - b.real()));
  return Line(c, p);
}

P crosspointLL(Line const& a, Line const& b) {
  P va = a[1] - a[0], vb = b[1] - b[0];
  double d = cross(vb, va);
  if(abs(d) < EPS) return b[0];
  return a[0] + va * cross(vb, b[1] - a[0]) * (1.0 / d);
}

vector<P> convex_cut(vector<P>& g, Line const& l) {
  vector<P> ret;
  rep(i, g.size()) {
    if(ccw(l[0], l[1], g[i]) != -1) ret.push_back(g[i]);
    if(ccw(l[0], l[1], g[i]) * ccw(l[0], l[1], g[(i+1)%g.size()]) < 0) {
      ret.push_back(crosspointLL(Line(g[i], g[(i+1)%g.size()]), l));
    }
  }
  return ret;
}

int main() {

  int N, M;
  while(cin >> N >> M && (N|M)) {
    vector<P> g;
    rep(i, N) {
      double x, y; cin >> x >> y;
      g.push_back(P(x, y));
    }

    vector<P> ps;
    rep(i, M) {
      double x, y; cin >> x >> y;
      ps.push_back(P(x, y));
    }

    rep(i, M) {
      auto p = g;
      rep(j, M) {
        if(i == j) continue;
        p = convex_cut(p, perpendicular_bisector(ps[i], ps[j]));
      }
      printf("%.10f\n", area(p));
    }
  }

  return 0;
}