//include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <queue>

using namespace std;

//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;

//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())

//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

//constant
//--------------------------------------------
const double mEPS = 1e-10;
const double PI  = acos(-1.0);

class Point{
public:
	double x, y;

	Point(double x = 0.0, double y = 0.0) : x(x), y(y){}

	Point operator + (Point p){ return Point(x + p.x, y + p.y); }
	Point operator - (Point p){ return Point(x - p.x, y - p.y); }
	Point operator * (double a){ return Point(a*x, a*y); }
	Point operator / (double a){ return Point(x / a, y / a); }

	double abs(){ return sqrt(norm()); }
	double norm(){ return x*x + y*y; }

	bool operator < (const Point &p) const{
		return x != p.x ? x < p.x : y < p.y;
	}

	//EPS??????????°??????????
	bool operator == (const Point &p) const {
		return fabs(x - p.x) < mEPS && fabs(y - p.y) < mEPS;
	}

};

class Segment{
public:
	Point p1, p2;
};

typedef vector<Point> Polygon;

//???????????¨????????±???
typedef Point Vector;
//???????????´?????¨????????±???
typedef Segment Line;

//??????
double dot(Vector a, Vector b){
	return a.x*b.x + a.y*b.y;
}

//???????????§??????
double cross(Vector a, Vector b){
	return a.x*b.y - a.y*b.x;
}
int ccw(Point p0, Point p1, Point p2){

	//p0->p1???p0?§???????p1?????????????????????????????¨????????¨???

	//p0->p2??????????¨??????????????????¨???
	static const int COUNTER_CLOCKWISE = 1;
	//p0->p2???????¨??????????????????¨???
	static const int CLOCKWISE = -1;
	//p2,p0,p1????????§????????´?????????????????¨???
	static const int ONLINE_BACK = 2;
	//p0,p1,p2 ????????§????????´?????????????????´???
	static const int ONLINE_FRONT = -2;
	//p2 ????????? p0p1 ??????????????´???
	static const int ON_SEGMENT = 0;

	Vector a = p1 - p0;
	Vector b = p2 - p0;

	if (cross(a, b) > mEPS) return COUNTER_CLOCKWISE;
	if (cross(a, b) < -mEPS) return CLOCKWISE;
	if (dot(a, b) < -mEPS) return ONLINE_BACK;
	if (a.norm() < b.norm()) return ONLINE_FRONT;

	return ON_SEGMENT;

}
Point getCrossPoint(Segment s1, Segment s2){
	Vector base = s2.p2 - s2.p1;
	double d1 = abs(cross(base, s1.p1 - s2.p1));
	double d2 = abs(cross(base, s1.p2 - s2.p1));
	double t = d1 / (d1 + d2);
	return s1.p1 + (s1.p2 - s1.p1)*t;
}
double polygon_area(Polygon t){
  double ans=0.0;
  for(unsigned int i=0;i<t.size();i++)
	ans+=cross(t[i] , t[(i+1)%t.size()]);
  return ans/2;
}

Polygon convex_cut(const Polygon& pol, const Line& l) {
  Polygon Q;
  for (unsigned int i = 0; i < pol.size(); ++i) {
    Point A = pol[i], B = pol[(i+1)%pol.size()];
    if (ccw(l.p1, l.p2, A) != -1) Q.push_back(A);
    if (ccw(l.p1, l.p2, A)*ccw(l.p1, l.p2, B) < 0){
	  Line tmp; tmp.p1 = A, tmp.p2 = B;
      Q.push_back(getCrossPoint(tmp, l));
	}
  }
  return Q;
}

Point rotate(Point p,double angle){
  return Point(p.x*cos(angle) - p.y*sin(angle),
			   p.x*sin(angle) + p.y*cos(angle));
}


int main(){
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  int N, M;
  while(cin>>N>>M,N){
	Polygon pol(N);
	REP(i,N) cin >> pol[i].x >> pol[i].y;
	vector<Point> ps(M);
	REP(i,M) cin >> ps[i].x >> ps[i].y;

	REP(i,M){
	  Polygon tmp = pol;
	  REP(j,M){
		if(i == j) continue;
		Line l;
		l.p1 = (ps[i] + ps[j]) / 2;
		l.p2 = rotate(ps[j] - ps[i], PI / 2) + l.p1;
		tmp = convex_cut(tmp, l);
	  }
	  cout << fixed << setprecision(9) << polygon_area(tmp) << endl;
	}
  }

  return 0;
}