#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>

#ifndef PREC
#define PREC (1)
#endif

using namespace std;

const double EPS = 1e-12;
const double INF = HUGE_VAL;
const double DLT = 1e-06;

const int NONE = -1;
const int MANY = -2;
const int PART = -2;
const int FULL = -3;

typedef complex<double> complex_t;

struct island_t
{
	vector<complex_t> v;
	double val;
};

static vector<island_t> vi;
static double d_erz;

int dblcmp(double x, double y)
{
	return (x - y > EPS) ? +1 : (y - x > EPS) ? -1 : 0;
}

bool contains(const vector<complex_t> &v,
			  const complex_t &z)
{
	int n = v.size();

	for(int i = 0; i < n; i++) {
		double x = imag( (z - v[i]) / (v[(i + 1) % n] - v[i]) );
		if(dblcmp(x, 0.0) < 0) return false;
	}

	return true;
}

double distance(const complex_t &z1, const complex_t &z2,
				const complex_t &z0)
{
	complex_t w = (z0 - z1) / (z2 - z1);
	if(dblcmp(real(w), 0.0) < 0) return abs(z0 - z1);
	if(dblcmp(real(w), 1.0) > 0) return abs(z0 - z2);
	return abs(z2 - z1) * abs(imag(w));
}

bool intersects(const complex_t &z1, const complex_t &z2,
				const complex_t &z3, const complex_t &z4)
{
	complex_t w3 = (z3 - z1) / (z2 - z1);
	complex_t w4 = (z4 - z1) / (z2 - z1);
	if(dblcmp(imag(w3), 0.0) * dblcmp(imag(w4), 0.0) >= 0) return false;
	double x = imag(w3 * conj(w4)) / imag(w3 - w4);
	return dblcmp(x, 0.0) * dblcmp(x, 1.0) <= 0;
}

int contains(const vector<complex_t> &v,
			 const complex_t z[4])
{
	{
		int n = 0;

		n += contains(v, z[0]) ? 1 : 0;
		n += contains(v, z[1]) ? 1 : 0;
		n += contains(v, z[2]) ? 1 : 0;
		n += contains(v, z[3]) ? 1 : 0;
	
		if(n == 4) return FULL;
		if(n >= 1) return PART;
	}

	{
		int n = v.size();

		for(int i = 0; i < n; i++) {
			int j = (i + 1) % n;
			if(intersects(v[i], v[j], z[0], z[1])) return PART;
			if(intersects(v[i], v[j], z[1], z[2])) return PART;
			if(intersects(v[i], v[j], z[2], z[3])) return PART;
			if(intersects(v[i], v[j], z[3], z[0])) return PART;
		}
	}

	return NONE;
}

double distance(const vector<complex_t> &v,
				const complex_t &z)
{
	double d = INF;
	{
		int n = v.size();
		for(int i = 0; i < n; i++) {
			d <?= distance(v[i], v[(i + 1) % n], z);
		}
	}

	return d;
}

int owner(const vector<complex_t> &v,
		  const complex_t z[4])
{
	int q = contains(v, z);
	if(q == NONE) { return NONE; }

	int n = vi.size();

	vector<double> dmax;
	vector<double> dmin;
	{
		dmax.assign(n, 0.0);
		dmin.assign(n, INF);

		for(int i = 0; i < n; i++) {
			for(int j = 0; j < 4; j++) {
				double d = distance(vi[i].v, z[j]);
				dmax[i] >?= d;
				dmin[i] <?= d;
			}

			for(int j = 0; j < vi[i].v.size(); j++) {
				dmin[i] <?= distance(z[0], z[1], vi[i].v[j]);
				dmin[i] <?= distance(z[1], z[2], vi[i].v[j]);
				dmin[i] <?= distance(z[2], z[3], vi[i].v[j]);
				dmin[i] <?= distance(z[3], z[0], vi[i].v[j]);
			}
		}
	}

	int s = NONE;
	double d_req = INF;
	{

		for(int i = 0; i < n; i++)
			d_req <?= dmax[i];

		for(int i = 0; i < n; i++) {
			if(dmin[i] < d_req && dmin[i] < d_erz)
				s = (s == NONE) ? i : MANY;
		}

	}

	if(s == NONE) { return NONE; }
	if(q == PART || d_req > d_erz) { return MANY; }
	return s;
}

// despite this problem being made by yuizumi
void kmatsu(const vector<complex_t> &v,
			double xu, double yu, double xv, double yv, double val)
{
	if(val < DLT) return;

	complex_t z[4] = {
		complex_t(xu, yu), complex_t(xv, yu),
		complex_t(xu, yv), complex_t(xv, yv)
	};

	int s = owner(v, z);

	if(s == NONE)
		return;

	if(s != MANY) {
		vi[s].val += val;
		return;
	}

	double xm = (xu + xv) / 2.0;
	double ym = (yu + yv) / 2.0;

	// recursive calls
	kmatsu(v, xu, yu, xm, ym, val / 4.0);
	kmatsu(v, xm, yu, xv, ym, val / 4.0);
	kmatsu(v, xu, ym, xm, yv, val / 4.0);
	kmatsu(v, xm, ym, xv, yv, val / 4.0);
}

int main(void)
{
	bool first = true;
	int ni, nr;

	while(cin >> ni >> nr) {
		if(ni == 0 && nr == 0) { break; }

		cin >> d_erz;

		vi.resize(ni);

		for(int i = 0; i < ni; i++) {
			int n;
			cin >> n;
			vi[i].v.resize(n);
			vi[i].val = 0;
			for(int j = 0; j < n; j++) {
				double x, y;
				cin >> x >> y;
				vi[i].v[j] = complex_t(x, y);
			}
		}

		for(int i = 0; i < nr; i++) {
			double val;
			int n;

			cin >> val >> n;

			double xu = +INF, xv = -INF;
			double yu = +INF, yv = -INF;

			vector<complex_t> v(n);
			for(int j = 0; j < n; j++) {
				double x, y;
				cin >> x >> y;
				v[j] = complex_t(x, y);
				xu <?= x; xv >?= x;
				yu <?= y; yv >?= y;
			}

			val *= (xv - xu) * (yv - yu);

			double xm = (xu + xv) / 2.0;
			double ym = (yu + yv) / 2.0;

			kmatsu(v, xu, yu, xm, ym, val / 4.0);
			kmatsu(v, xm, yu, xv, ym, val / 4.0);
			kmatsu(v, xu, ym, xm, yv, val / 4.0);
			kmatsu(v, xm, ym, xv, yv, val / 4.0);
		}

		if(!first) cout << endl;
		first = false;

		for(int i = 0; i < ni; i++) {
			cout << fixed << setprecision(PREC) << vi[i].val << endl;
		}
	}

	return 0;
}