#include<iostream>
#include<cmath>
#include<cassert>
#include<map>
#include<vector>
#include<queue>
#include<complex>

#define REP(i, b, n) for(int i = b; i<(int)n; i++)
#define rep(i, n) REP(i, 0, n)

using namespace std;

#define X real()
#define Y imag()

typedef long double D;
typedef complex<D> P;
struct L{P a, b;};
typedef vector<P> Pol;

const D EPS = 1e-6;
const D PI = acos(-1);

int sig(D a, D b = 0) {return a < b - EPS ? -1 : a > b + EPS ? 1 : 0;}
bool near(P a, P b) {return !sig(norm(a - b));}
namespace std {
  bool operator<(P a, P b) {return sig(a.X, b.X) ? a.X < b.X : a.Y < b.Y;}
}

D dot(P a, P b) {return a.X * b.X + a.Y * b.Y;}
D det(P a, P b) {return a.X * b.Y - a.Y * b.X;}
P vec(L a) {return a.b - a.a;}

D arg(P base, P a, P b) {return arg((b - base) / (a - base));}

enum CCW{FRONT = 1, RIGHT = 2, BACK = 4, LEFT = 8, ON = 16};
int ccw(P a, P b, P c) {
  if (near(a, c)) return BACK;
  if (near(b, c)) return FRONT;
  int s = sig(det(b - a, c - a));
  if (s) return s > 0 ? LEFT : RIGHT;
  return (a < b) == (b < c) ? FRONT : (c < a) == (a < b) ? BACK : ON;
}

P proj(P a, P b) {return a * dot(a, b) / norm(a);}
P perp(L l, P p) {return l.a + proj(vec(l), p - l.a);}
P refl(L l, P p) {return perp(l, p) * (D)2 - p;}

D dLP(L l, P p) {return abs(det(vec(l), p - l.a) / vec(l));}
D dSP(L s, P p) {
  if (dot(vec(s), p - s.a) < 0) return abs(p - s.a);
  if (dot(vec(s), p - s.b) > 0) return abs(p - s.b);
  return dLP(s, p);
}

struct C{P c; D r;};

bool iCSs(C c, L s) {return sig(c.r , dSP(s, c.c)) > 0;}

const int MAX_V = 150;
const int INF = 1e9;

class State{
public:
  int cost, pos;
  bool operator<(const State &s)const{
    return cost > s.cost;
  }
};

class Edge{
public:
  int to, cap, cost, rev;
};

int V, h[MAX_V], dist[MAX_V], prevv[MAX_V], preve[MAX_V];
vector<Edge> G[MAX_V];

void addEdge(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 res;

int min_cost_flow(int s, int t, int f){
  int cnt = 0;
  int ret = 0;
  rep(i, V)h[i] = 0;
  while(f>0){
    priority_queue<State> Q;
    rep(i, V)dist[i] = INF;
    dist[s] = 0;
    Q.push((State){0, s});
    while(!Q.empty()){
      State now = Q.top();
      Q.pop();
      int v = now.pos;
      if(dist[v] < now.cost)continue;
      rep(i, G[v].size()){
	Edge e = G[v][i];
	if(e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]){
	  dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
	  prevv[e.to] = v;
	  preve[e.to] = i;
	  Q.push((State){dist[e.to], e.to});
	}
      }
    }
    if(dist[t] == INF)return -1;
    rep(v, V)h[v] += dist[v];
    int mini = f;
    for(int v = t; v!= s; v=prevv[v]){
      mini = min(mini, G[prevv[v]][preve[v]].cap);
    }
    f -= mini;
    ret += mini * h[t];
    ++cnt;
    res = max(res, -ret + cnt * 100);
    for(int v = t; v!= s; v= prevv[v]){
      Edge &e = G[prevv[v]][preve[v]];
      e.cap -= mini;
      G[v][e.rev].cap += mini;
    }
  }
  return ret;
}

P reflC(P a, P b, C c) {
  if (sig(arg(c.c, a, b)) < 0) swap(a, b);
  D high = arg(c.c, a, b), low = 0, ang = arg(a - c.c);
  rep (i, 200) {
    D mid = (high + low) / (D)2;
    P p = c.c + polar(c.r, mid + ang);
    if (arg(p, c.c, a) < arg(p, b, c.c)) high = mid;
    else low = mid;
  }
  return c.c + polar(c.r, low + ang);
}

struct Bydol {
  P pos;
  D p;
  int q;
  int r;
  int s;
};

int solve(vector<Bydol> a, vector<Bydol> b, vector<C> vc) {
  bool sh[a.size()][b.size()];
  rep (i, a.size()) rep (j, b.size()) {
    L s = (L){a[i].pos, b[j].pos};
    bool ok = true;
    if (sig(abs(vec(s)), a[i].p) > 0) ok = false;
    rep (k, vc.size()) if (iCSs(vc[k], s)) ok = false;
    rep (k, a.size()) if (ccw(s.a, s.b, a[k].pos) == ON) ok = false;
    rep (k, b.size()) if (ccw(s.a, s.b, b[k].pos) == ON) ok = false;
    sh[i][j] = ok;
    if (sh[i][j] == false && a[i].r == 1) {
      rep (v, vc.size()) {
	if (iCSs(vc[v], (L){a[i].pos, b[j].pos})) continue;
	P p = reflC(a[i].pos, b[j].pos, vc[v]);
	//P p = reflC(vc[v], a[i].pos, b[j].pos);
	//cout << p << endl;
	L s = (L) {a[i].pos, p};
	bool ok = true;
	if (sig(abs(vec(s)) + abs(p - b[j].pos), a[i].p) > 0) ok = false;
	rep (k, vc.size()) if (iCSs(vc[k], s)) ok = false;
	rep (k, a.size()) if (ccw(s.a, s.b, a[k].pos) == ON) ok = false;
	rep (k, b.size()) if (ccw(s.a, s.b, b[k].pos) == ON) ok = false;
	s = (L) {p, b[j].pos};
	rep (k, vc.size()) if (iCSs(vc[k], s)) ok = false;
	rep (k, a.size()) if (ccw(s.a, s.b, a[k].pos) == ON) ok = false;
	rep (k, b.size()) if (ccw(s.a, s.b, b[k].pos) == ON) ok = false;
      	if (ok) {
	  sh[i][j] = true;
	  break;
	}
      }
    }
  }

  //rep (i, a.size()) rep (j, b.size()) cout << i << " " << j << " " << sh[i][j] << endl;

  rep (i, MAX_V) G[i].clear();
  V = a.size() + b.size() + 2;
  res = 0;
    
  rep (i, a.size()) addEdge(0, i + 1, a[i].q, 0);
  rep (i, a.size()) rep (j, b.size()) if (sh[i][j]) addEdge(i + 1, j + 1 + a.size(), 1, 0);
  rep (j, b.size()) addEdge(j + 1 + a.size(), a.size() + b.size() + 1, 1, 100 - b[j].s);
  min_cost_flow(0, a.size() + b.size() + 1, b.size());
  return res;
}

int main(){
  int n, m, o;
  cin >> n >> m >> o;
  vector<Bydol> a, b;
  rep (i, n) {
    Bydol by;
    cin >> by.pos.X >> by.pos.Y >> by.p >> by.q >> by.r >> by.s;
    a.push_back(by);
  }
  rep (i, m) {
    Bydol by;
    cin >> by.pos.X >> by.pos.Y >> by.p >> by.q >> by.r >> by.s;
    b.push_back(by);
  }
  vector<C> vc(o);
  rep (i, o) cin >> vc[i].c.X >> vc[i].c.Y >> vc[i].r;
  
  int resa = solve(a, b, vc);
  int resb = solve(b, a, vc);

  cout << resa << " " << resb << endl;
  if (resa > resb) cout << "win" << endl;
  else if (resa == resb) cout << "draw" << endl;
  else cout << "lose" << endl;

  return 0;
}

Measured memory_bytes: 1420