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


using ld = long double;
constexpr ld eps = 1e-8;


namespace geometry2d {


using point = std::complex<long double>;
using polygon = std::vector<point>;

bool eq(ld a, ld b) {
    return (std::abs(a - b) < eps);
}

long double dot(point a, point b) {
    return std::real(std::conj(a) * b);
}

long double cross(point a, point b) {
    return std::imag(std::conj(a) * b);
}

class line {
public:
    line()
        : a(point(0, 0)), b(point(0, 0))
    {}
    line(point a_, point b_)
        : a(a_), b(b_)
    {}

    point a, b;
};

int ccw(point a, point b, point c) {
    b -= a; c -= a;
    if(cross(b, c) > eps)           return 1;  // a -> b -> c : counterclockwise
    if(cross(b, c) < -eps)          return -1; // a -> b -> c : clockwise
    if(dot(b, c) < 0)               return 2;  // c -> a -> b : line
    if(std::norm(b) < std::norm(c)) return -2; // a -> b -> c : line
    return 0;                                  // a -> c -> b : line
}

point is_ll(line s, line t) {
    point sv = s.b - s.a, tv = t.b - t.a;
    assert(cross(sv, tv) != 0);
    return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}


ld area(polygon const& p) {
    const int N = p.size();
    ld res = 0;
    for(int i=0; i<N; ++i) {
        res += cross(p[i], p[(i+1)%N]);
    }
    return res / 2;
}

// left side
polygon convex_cut(polygon const& p, line l) {
    const int N = p.size();
    polygon res;
    for(int i=0; i<N; ++i) {
        auto a = p[i], b = p[(i+1)%N];
        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;
}


line separate(point const& p1, point const& p2) {
    assert(p1 != p2);
    auto m = (p1 + p2) * point(0.5, 0);
    line res;
    res.a = m + (m - p1) * point(0, 1);
    res.b = m + (m - p1) * point(0, -1);
    return res;
}


} // namespace geometry2d

using namespace geometry2d;


int main() {
    int N, M;
    while(cin >> N >> M, N) {
        polygon p;
        for(int i=0; i<N; ++i) {
            ld x, y;
            cin >> x >> y;
            p.emplace_back(x, y);
        }
        vector<point> C;
        for(int i=0; i<M; ++i) {
            ld x, y;
            cin >> x >> y;
            C.emplace_back(x, y);
        }
        for(int i=0; i<M; ++i) {
            auto p2 = p;
            for(int j=0; j<M; ++j) {
                if(i == j) {
                    continue;
                }
                line l = separate(C[i], C[j]);
                if(ccw(l.a, l.b, C[i]) == -1) {
                    swap(l.a, l.b);
                }
                p2 = convex_cut(p2, l);
            }
            cout << fixed << setprecision(10) << area(p2) << endl;
        }
    }
}
