#include <bits/stdc++.h>
using namespace std;
#define int long long   // <-----!!!!!!!!!!!!!!!!!!!

#define rep(i,n) for (int i=0;i<(n);++i)
#define rep2(i,a,b) for (int i=(a);i<(b);++i)
#define rrep(i,n) for (int i=(n)-1;i>=0;--i)
#define rrep2(i,a,b) for (int i=(a)-1;i>=b;--i)
#define chmin(a,b) (a)=min((a),(b));
#define chmax(a,b) (a)=max((a),(b));
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define printV(v) cout<<(#v)<<":";for(auto(x):(v)){cout<<" "<<(x);}cout<<endl;
#define printVS(vs) cout<<(#vs)<<":"<<endl;for(auto(s):(vs)){cout<<(s)<< endl;}
#define printVV(vv) cout<<(#vv)<<":"<<endl;for(auto(v):(vv)){for(auto(x):(v)){cout<<" "<<(x);}cout<<endl;}
#define printP(p) cout<<(#p)<<(p).first<<" "<<(p).second<<endl;
#define printVP(vp) cout<<(#vp)<<":"<<endl;for(auto(p):(vp)){cout<<(p).first<<" "<<(p).second<<endl;}

inline void output(){ cout << endl; }
template<typename First, typename... Rest>
inline void output(const First& first, const Rest&... rest) {
    cout << first << " "; output(rest...);
}

using ll = long long;
using Pii = pair<int, int>;
using TUPLE = tuple<int, int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
const int inf = 1e9;
const int mod = 1e9 + 7;
using Graph = vector<vector<int>>;

typedef complex<long double> P;
typedef vector<P> G;
#define here(g, i) g[i]
#define next(g, i) g[(i + 1) % g.size()]
#define prev(g, i) g[(i - 1 + g.size()) % g.size()]
const long double EPS = 1e-10;
const long double INF = 1e12;
const long double PI = acos(-1);

struct L {
    P a, b, v;
    L(){}
    L(P _a, P _b) : a(_a), b(_b), v(b - a) {}
    L(long double _ax, long double _ay, long double _bx, long double _by) : L(P(_ax, _ay), P(_bx, _by)) {}
    void reverse() {
        swap(a, b); v = b - a;
    }
};

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

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

// signed!!!!!!!!!
long double areaG(G g) {
    int n = g.size();
    long double ret = 0.l;
    rep(i, n) {
        ret += cross(here(g, i), next(g, i));
    }
    return ret / 2.l;
}

P readP() {
    long double x, y;
    cin >> x >> y;
    return P(x, y);
}

G readG(int n) {
    // int n;
    // cin >> n;
    G g(n);
    rep(i, n) g[i] = readP();
    return g;
}

L PerpendicularBisector(P p, P q) {
    P c = (p + q) / 2.l;
    P d = (q - p) / 2.l;
    P h = d * P(0.l, 1.l);
    return L(c + h, c - h);
}

int ccw(P p0, P p1, P p2) {
    p1 -= p0; p2 -= p0;
    if (cross(p1, p2) > 0.l) return +1;       // counter-clockwise
    if (cross(p1, p2) < 0.l) return -1;       // clockwise
    if (dot(p1, p2) < 0.l) return +2;         // p2 -- p0 -- p1
    if (norm(p1) < norm(p2)) return -2;     // p0 -- p1 -- p2
    return 0.l;                               // p0 -- p2 -- p1
}

P crosspointLL(L l1, L l2) {
    return l1.a + l1.v * cross(l2.v, l2.a - l1.a) / cross(l2.v, l1.v);
}

G convex_cut(G g, L l) {
    G h;
    rep(i, (int)g.size()) {
        P p = here(g, i), q = next(g, i);
        if (ccw(p, q, l.a) == 0 && ccw(p, q, l.b) == 0) {
            if (ccw(p, l.b, l.a) == 0) return g;    // p -- l.a -- l.b -- q
            else return G{};                        // p -- l.b -- l.a -- q
        }
        if (ccw(l.a, l.b, p) != -1) h.emplace_back(p);
        if (ccw(l.a, l.b, p) * ccw(l.a, l.b, q) < 0)
        h.emplace_back(crosspointLL(L(p, q), l));
    }
    return h;
}

vector<G> Voronoi(G g, vector<P> p) {
    vector<G> ret;
    rep(i, p.size()) {
        G h = g;
        rep(j, p.size()) {
            if (i == j) continue;
            L l = PerpendicularBisector(p[i], p[j]);
            if (ccw(l.a, l.b, p[i]) == -1) l.reverse();
            h = convex_cut(h, l);
        }
        ret.emplace_back(h);
    }
    return ret;
}

main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);

    int n, m;
    while (cin >> n >> m, n) {
        G g = readG(n);
        vector<P> p(m);
        rep(i, m) p[i] = readP();

        auto vg = Voronoi(g, p);
        rep(i, vg.size()) {
            cout << fixed << setprecision(10) << abs<long double>(areaG(vg[i])) << endl;
        }
    }
}

Measured memory_bytes: 3284