/*
Bairstow法のコードはhttp://amzn.to/XUhRZkを参考
*/

#include <iostream>
#include <cstdio>
#include <vector>
#include <complex>
#include <cmath>
#include <algorithm>
using namespace std;

#define EPS_S 1e-10
#define EPS 1e-7
#define INF 1000000000

typedef complex<double> P;
typedef const P &rP;
typedef vector<double> vdbl;
typedef vector<P> vP;
typedef vector<int> vint;

double pi;

void bairstow(double &p, double &q, vdbl &a){
	int n = a.size() - 1;
	
	vdbl b(n + 1), c(n + 1);
	double dp, dq, e;
	
	p = q = 1.0;
	int cnt = 0;
	do{
		b[0] = a[0];
		b[1] = a[1] - p * b[0];
		
		for(int k = 2; k <= n; ++k){
			b[k] = a[k] - p * b[k-1] - q * b[k-2];
		}
		c[0] = b[0];
		c[1] = b[1] - p * c[0];
		for(int k = 2; k <= n; ++k){
			c[k] = b[k] - p * c[k-1] - q * c[k-2];
		}
		e = c[n-2] * c[n-2] - c[n-3] * (c[n-1] - b[n-1]);
		if(abs(e) < EPS_S){ break; }
		dp = (b[n-1] * c[n-2] - b[n] * c[n-3]) / e;
		dq = (b[n] * c[n-2] - b[n-1] * (c[n-1] - b[n-1])) / e;
		p += dp;
		q += dq;
	}while(++cnt < 1000 && min(abs(dp), abs(dp)) > EPS_S);

	a.swap(b);
}

vector<P> solve_powered(vdbl a){
	vector<P> ret;

	while(!a.empty() && abs(a.back()) < EPS_S){
		a.pop_back();
	}
	
	reverse(a.begin(), a.end());
	
	while(a.size() > 1){
		if(a.size() == 2){
			ret.push_back(-a[1] / a[0]);
		}
		else{
			double p, q;
			if(a.size() == 3){
				p = a[1] / a[0];
				q = a[2] / a[0];
			}
			else{
				bairstow(p, q, a);
			}

			P rt = sqrt(P(p * p - 4.0 * q));
			ret.push_back((-p + rt) * 0.5);
			ret.push_back((-p - rt) * 0.5);
		}
		
		a.resize(a.size() - 2);
	}
	
	return ret;
}


double dot(rP a, rP b){
	return real(a) * real(b) + imag(a) * imag(b);
}

double cross(rP a, rP b){
	return real(a) * imag(b) - imag(a) * real(b);
}

bool containssp(rP a, rP b, rP t){
	if(norm(a - t) < EPS || norm(b - t) < EPS){ return false; }
	if(abs(cross(t - a, b - t)) > EPS){ return false; }
	return dot(t - a, b - t) > -EPS;
}


void check_reflect(
	double ux, double uy, P from, P to, P center, double r, vP &res
){
	P u(ux, uy);
	P at = center + r * u;
	
	from -= at;
	to -= at;
	P rfl = from - 2.0 * dot(from, u) * u;

	if(abs(cross(rfl, to)) < EPS && dot(rfl, to) < EPS){
		res.push_back(at);
	}
}

vector<P> Reflect2D(rP from, rP to, rP center, double r){
	P a = from - center, b = to - center;

	double c1 = cross(conj(a), b);
	double c2 = dot(conj(a), b);
	double c3 = r * real(a + b);
	double c4 = r * imag(a + b);

	vector<double> v(5);
	v[0] = c1 * c1 - c3 * c3;
	v[1] = 2.0 * c1 * c4 + 4.0 * c2 * c3;
	v[2] = c3 * c3 + c4 * c4 - 4.0 * c1 * c1 - 4.0 * c2 * c2;
	v[3] = -4.0 * (c1 * c4 + c2 * c3);
	v[4] = 4.0 * (c1 * c1 + c2 * c2);

	vector<P> bs = solve_powered(v);

	vector<P> ret;
	for(int i = 0; i < bs.size(); ++i){
		double x = min(1.0, max(-1.0, real(bs[i])));
		double y = sqrt(1 - x * x);
		check_reflect(x, y, from, to, center, r, ret);
		check_reflect(x, -y, from, to, center, r, ret);
	}

	return ret;
}


double intersectcs(rP s, double r, rP p, rP q){
	P v = q - p;
	double a = norm(v);
	double b = dot(v, p - s);
	double c = norm(p - s) - r * r;
	double D = b * b - a * c;
	if(D > EPS){
		D = sqrt(D);
		double t;
		t = (-b + D) / a;
		if(t > EPS && t < 1.0 - EPS){ return true; }
		t = (-b - D) / a;
		if(t > EPS && t < 1.0 - EPS){ return true; }
	}
	return false;
}


bool can_reach(
	rP from, rP rfl, rP to, vP &wc, vdbl &wr, double p, vP pos[]
){
	double d = abs(from - rfl) + abs(to - rfl);
	if(d > p + EPS){ return false; }
	for(int i = 0; i < wc.size(); ++i){
		if(intersectcs(wc[i], wr[i], from, rfl)){ return false; }
		if(intersectcs(wc[i], wr[i], rfl, to)){ return false; }
	}
	for(int i = 0; i < 2; ++i)
	for(int j = 0; j < pos[i].size(); ++j){
		if(containssp(from, rfl, pos[i][j])){ return false; }
		if(containssp(rfl, to, pos[i][j])){ return false; }
	}

	return true;
}


void input(int n, vP &z, vdbl &p, vint &q, vint &r, vint &s){
	z.resize(n);
	p.resize(n);
	q.resize(n);
	r.resize(n);
	s.resize(n);
	
	int x, y;
	for(int i = 0; i < n; ++i){
		scanf("%d%d%lf%d%d%d", &x, &y, &p[i], &q[i], &r[i], &s[i]);
		z[i] = P(x, y);
	}
}


struct edge{ int to, cap, cost, rev; };
struct graph{
	int V;
	vector<vector<edge> > G;
	vint dist;
	vint prevv, preve;

	graph(int n): V(n), G(n), dist(n), prevv(n), preve(n) {}

	void add_edge(int from, int to, int cap, int cost){
		G[from].push_back((edge){to, cap, cost, G[to].size()});
		G[to].push_back((edge){from, 0, -cost, G[from].size() - 1});
	}
	
	int min_cost_flow(int s, int t, int f){
		int res = 0;
		while(f > 0){
			fill(dist.begin(), dist.end(), INF);
			dist[s] = 0;
			bool update = true;
			while(update){
				update = false;
				for(int v = 0; v < V; ++v){
					if(dist[v] == INF){ continue; }
					for(int i = 0; i < G[v].size(); ++i){
						edge &e = G[v][i];
						if(e.cap > 0 && dist[e.to] > dist[v] + e.cost){
							dist[e.to] = dist[v] + e.cost;
							prevv[e.to] = v;
							preve[e.to] = i;
							update = true;
						}
					}
				}
			}
			
			if(dist[t] == INF){ break; }
		
			int d = f;
			for(int v = t; v != s; v = prevv[v]){
				d = min(d, G[prevv[v]][preve[v]].cap);
			}
			f -= d;
			res += d * dist[t];
			for(int v = t; v != s; v = prevv[v]){
				edge &e = G[prevv[v]][preve[v]];
				e.cap -= d;
				G[v][e.rev].cap += d;
			}
		}

		return res;
	}
};



int main(){
	pi = acos(-1.0);

	int n[2], wall;
	scanf("%d%d%d", &n[0], &n[1], &wall);

	vP pos[2];
	vdbl p[2];
	vint q[2], r[2], s[2];
	for(int i = 0; i < 2; ++i){
		input(n[i], pos[i], p[i], q[i], r[i], s[i]);
	}
	
	vP wc(wall);
	vdbl wr(wall);
	for(int i = 0; i < wall; ++i){
		int x, y;
		scanf("%d%d%lf", &x, &y, &wr[i]);
		wc[i] = P(x, y);
	}

	int score[2] = {};
	for(int i = 0; i < 2; ++i){
		int src = n[0] + n[1];
		int snk = src + 1;
		graph G(snk + 1);

		for(int j = 0; j < n[i]; ++j){
			G.add_edge(src, j, q[i][j], 0);

			rP from = pos[i][j];
			for(int k = 0; k < n[1-i]; ++k){

				rP to = pos[1-i][k];
				
				vP rfl;
				rfl.push_back(0.5 * (from + to));

				if(r[i][j]){
					for(int h = 0; h < wall; ++h){
						vP ret = Reflect2D(from, to, wc[h], wr[h]);
						rfl.insert(rfl.end(), ret.begin(), ret.end());
					}
				}

				for(int g = 0; g < rfl.size(); ++g){
					if(can_reach(from, rfl[g], to, wc, wr, p[i][j], pos)){
						G.add_edge(j, k + n[i], 1, 0);
					}
				}
			}
		}
		for(int k = 0; k < n[1-i]; ++k){
			G.add_edge(k + n[i], snk, 1, -s[1-i][k]);
		}
		
		score[i] = -G.min_cost_flow(src, snk, INF);
	}
	
	const char *msg = "draw";
	if(score[0] < score[1]){ msg = "lose"; }
	else if(score[0] > score[1]){ msg = "win"; }
	printf("%d %d\n%s\n", score[0], score[1], msg);
}

Measured memory_bytes: 1380