#include<iostream>
#include<complex>
#include<vector>
#include<queue>
#include<cmath>
#include<algorithm>
#include<cstdio>
 
using namespace std;
 
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define X real()
#define Y imag()
 
typedef long double D;
typedef complex<D> P;
typedef pair<P, P> L;
typedef vector<P> Pol;
 
const D INF = 1e40;
const D EPS = 1e-8;
const D PI = acos(-1);
 
int sig(D r) {return (r < -EPS) ? -1 : (r > EPS) ? 1 : 0;}
bool eq(D a, D b) {return abs(a - b) < EPS;}
bool near(P a, P b) {return abs(a - b) < EPS;}
 
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.second - a.first;}
 
enum CCW{FRONT = 1, RIGHT = 2, BACK = 4, LEFT = 8, ON = 16};
int ccw(L s, P p) {
  P a = vec(s);
  p -= s.first;
  D cr = det(a, p);
  if (eq(cr, 0)) {
    if (sig(dot(a, p)) <= 0) return BACK;
    if (sig(norm(a) - norm(p)) <= 0) return FRONT;
    return ON;
  }
  return (cr > 0) ? LEFT : RIGHT;
}
 
D ang(P base, P a, P b) {return arg((b - base) / (a - base));}
 
D dLP(L l, P x) {return abs(det(vec(l), x - l.first)) / abs(vec(l));}
D dSP(L s, P x) {
  if (sig(dot(vec(s), x - s.first)) <= 0) return abs(x - s.first);
  if (sig(dot(-vec(s), x - s.second)) <= 0) return abs(x - s.second);
  return dLP(s, x);
}
 
struct C{
  P c; D r;
  C() {}
  C(P c, D r) : c(c), r(r) {}
};
 
bool iCL(C c, L l) {return sig(c.r - dLP(l, c.c)) > 0;}
bool iCS(C c, L s) {return sig(c.r - dSP(s, c.c)) > 0;}
 
struct Bydol {
  P p;
  D d;
  int n, r, s;
};
 
typedef pair<int, int> PP;
struct edge {int to, cap, cost, rev;};
 
const int MAX_V = 111;
int V;
vector<edge> G[MAX_V];
int h[MAX_V];
int dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];
const int IN = 1e9;
 
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;
  fill(h, h + V, 0);
  while (f > 0) {
    priority_queue<PP, vector<PP>, greater<PP> > que;
    fill(dist, dist + V, IN);
    dist[s] = 0;
    while (true) {
      bool update = false;
      rep (v, V) if (dist[v] != IN) 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;
        update = true;
      }
    }
      if (!update) break;
    }
    if (dist[t] == IN) {
      throw 0;
    }
    for (int v = 0; v < V; ++v) h[v] += dist[v];
    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 * h[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;
}
 
bool can[2][60][60];
 
// 反射点を3分探索
P reflC(C c, P a, P b) {
  D low, high;
  P ppp = (a - c.c) * c.r / abs(a - c.c) + c.c;
  low = 0;
  high = ang(c.c, a, b);
  D dm1, dm2;
  rep (abc, 100) {
    D mid1 = (low * 2 + high) / 3;
    D mid2 = (low + high * 2) / 3;
    P mp1 = (ppp - c.c) * polar((D)1, mid1) + c.c;
    P mp2 = (ppp - c.c) * polar((D)1, mid2) + c.c;
    dm1 = abs(mp1 - a) + abs(mp1 - b);
    dm2 = abs(mp2 - a) + abs(mp2 - b);
    if (dm1 > dm2) low = mid1;
    else high = mid2;
  }
  return (ppp - c.c) * polar((D)1, low) + c.c;
}
 
int main() {
  int n, m , o;
  cin >> n >> m >> o;
  vector<Bydol> w[2];
  vector<C> vc(o);
 
  // 入力
  rep (i, n) {
    Bydol b;
    cin >> b.p.X >> b.p.Y >> b.d >> b.n >> b.r >> b.s;
    w[0].push_back(b);
  }
  rep (i, m) {
    Bydol b;
    cin >> b.p.X >> b.p.Y >> b.d >> b.n >> b.r >> b.s;
    w[1].push_back(b);
  }
  rep (i, o) cin >> vc[i].c.X >> vc[i].c.Y >> vc[i].r;
 
  // 直接当てれるか
  rep (iii, 2) rep (i, w[iii].size()) rep (j, w[iii ^ 1].size()) {
    L l(w[iii][i].p, w[iii ^ 1][j].p);
    if (sig(abs(vec(l)) - w[iii][i].d) > 0) continue;
    bool ok = true;
    rep (k, o) if (iCS(vc[k], l)) ok = false;
    rep (i2, 2) rep (j2, w[i2].size()) if (ccw(l, w[i2][j2].p) == ON) ok = false; 
    if (ok) can[iii][i][j] = true;
  }
 
  // 反射して当てれるか
  rep (iii, 2) rep (i, w[iii].size()) if (w[iii][i].r == 1) rep (jj, w[iii ^ 1].size()) rep (k, o) {
      Bydol now, tar;
      now = w[iii][i];
      tar = w[iii ^ 1][jj];
      if (iCS(vc[k], L(now.p, tar.p))) continue;
      P ref = reflC(vc[k], now.p, tar.p);
       
      //反射点が条件に一致しているか
      if (sig(abs(now.p - ref) + abs(tar.p - ref) - now.d) > 0) continue;
      bool ok = true;
      rep (kk, o) if (iCS(vc[kk], L(now.p, ref))) ok = false;
      rep (kk, o) if (iCS(vc[kk], L(tar.p, ref))) ok = false;
      rep (ii, 2) rep (jjj, w[ii].size()) if (ccw(L(now.p, ref), w[ii][jjj].p) == ON) ok = false;
      rep (ii, 2) rep (jjj, w[ii].size()) if (ccw(L(tar.p, ref), w[ii][jjj].p) == ON) ok = false;
      if (!ok) continue;
      can[iii][i][jj] = true;
    }
 
  // 最小費用流
  int res1 = 0, res2 = 0;
  V = n + m + 2;
  for (int iii = 1; ; ++iii) {
    rep (i, n + m + 2) G[i].clear();
    rep (i, w[0].size()) rep (j, w[1].size()) if (can[0][i][j]) {
      add_edge(i, j + n, 1, 0);
    }
    rep (i, w[0].size()) {
      add_edge(n + m, i, w[0][i].n, 0);
    }
    rep (j, w[1].size()) {
      add_edge(j + n, n + m + 1, 1, -w[1][j].s);
    }
    try {
      int mcf = min_cost_flow(n + m, n + m + 1, iii);
      res1 = max(res1, -mcf);
    } catch (int n) {
      break;
    }
  }
  for (int iii = 1; ; ++iii) {
    rep (i, n + m + 2) G[i].clear();
    rep (i, w[1].size()) rep (j, w[0].size()) if (can[1][i][j]) {
      add_edge(i, j + m, 1, 0);
    }
    rep (i, w[1].size()) {
      add_edge(n + m, i, w[1][i].n, 0);
    }
    rep (j, w[0].size()) {
      add_edge(j + m, n + m + 1, 1, -w[0][j].s);
    }
    try {
      int mcf = min_cost_flow(n + m, n + m + 1, iii);
      res2 = max(res2, -mcf);
    } catch (int n) {
      break;
    }
  }
  cout << res1 << " " << res2 << endl;
  if (res1 > res2) cout << "win\n";
  else if (res1 < res2) cout << "lose\n";
  else cout << "draw\n";
  return 0;
}

Measured memory_bytes: 1476