#include <iostream>
#include <iomanip>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <cassert>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define chmax(a,b) (a<(b)?(a=b,1):0)
#define chmin(a,b) (a>(b)?(a=b,1):0)
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
const int INF = 1<<29;
const double EPS = 1e-8;
const double PI = acos(-1);
typedef pair<int,int> pii;
typedef long long ll;

typedef complex<double> P;
P pIN() { double x,y; cin >> x >> y; return P(x,y); }
namespace std {
  bool operator < (const P& a, const P& b) {
    // if (abs(a-b)<EPS) return 0;
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
double cross(const P& a, const P& b) {
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
  return real(conj(a)*b);
}
struct L : public vector<P> {
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
  L() { resize(2); }
};
ostream &operator<<(ostream &os, const L &a) {
  os << a[0] << " -> " << a[1];
  return os;
}
typedef vector<P> G;
#define curr(g, i) g[i]
#define next(g, i) g[(i+1)%g.size()]

struct C {
  P p; double r;
  C(const P &p, double r) : p(p), r(r) { }
  C() {}
};
int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > EPS)   return +1;       // counter clockwise
  if (cross(b, c) < -EPS)   return -1;       // clockwise
  if (dot(b, c) < -EPS)     return +2;       // c--a--b on line
  if (EPS < norm(b) && norm(b) < norm(c)-EPS) return -2; // a--b--c on line
  return 0;
}
bool intersectLL(const L &l, const L &m) {
  return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
         abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;   // same line
}
bool intersectLS(const L &l, const L &s) {
  return cross(l[1]-l[0], s[0]-l[0])*       // s[0] is left of l
         cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
  return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSS2(const L &s, const L &t) { // 接しているやつは交差と考えない
  REP(i, 2) {
    if (ccw(s[0], s[1], t[i]) == 0) {
      int c = ccw(s[0],s[1],t[!i]);
      if (s[0] == t[i]) {
        if (c!=-2&&c) return 0;
      } else if (s[1] == t[i]) {
        if (c!=2&&c) return 0;
      } else if (abs(c)==1) return 0;
    }
  }
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}

P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
  return p + P(2,0) * (projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
  return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}

vector<P> crosspointLC(const L &l, const C &c) {
  vector<P> ret;
  P center = projection(l, c.p);
  double d = abs(center - c.p);
  if (c.r * c.r - d * d < -EPS) return ret;
  double t = sqrt(max(0.0,c.r * c.r - d * d));
  P vect = (l[1] - l[0]);
  vect /= abs(vect);
  ret.push_back(center - vect * t);
  if (t > EPS) {
    ret.push_back(center + vect * t);
  }
  return ret;
}
vector<P> crosspointSC(const L &s, const C &c) {
  vector<P> ret;
  vector<P> nret = crosspointLC(s, c);
  FOR(it, nret)
    if (intersectSP(s, *it))
      ret.push_back(*it);
   return ret;
}

// ベクトルａからみたベクトルｂの角度の[0,2pi)
double angle(const P &a, const P &b) {
  double ret = arg(b)-arg(a);
  return (ret>=0) ? ret : ret + 2*PI;
}
// ベクトルaとベクトルbの間の角度
double angle2(const P &a, const P &b) {
  return min(angle(a,b), angle(b,a));
}

// pから出たレーザーがcで反射してqに到達するようなときの反射
// p-qとcがintersectしていないときのみ
P reflectPoint(P p, P q, C c) {
  p -= c.p;
  q -= c.p;
  double low = 0, high = 1;
  P refl;
  REP(_,100) {
    double mid = (low+high)/2;
    P mp = mid*p + (1-mid)*q;
    double ang = atan2(mp.imag(), mp.real());
    refl = polar(c.r,ang);
    double a1 = angle2(refl, p-refl);
    double a2 = angle2(refl, q-refl);
    if (a1>a2) {
      low = mid;
    } else {
      high = mid;
    }
  }
  // cout << low << endl;
  // double a1 = angle2(refl, p-refl);
  // double a2 = angle2(refl, q-refl);
  // cout << refl << " " << p << " " << q << endl;
  // cout << a1 << " " << a2 << endl;

  // cout << c.p + refl << endl;
  return c.p + refl;
}

typedef int Weight;
struct Edge {
  int src, dst;
  Weight capacity, cost;
  int rev;
  Edge(int src, int dst, Weight capacity, Weight cost) :
    src(src), dst(dst), capacity(capacity), cost(cost) { }
  Edge(int src, int dst, Weight capacity, Weight cost, int rev) :
    src(src), dst(dst), capacity(capacity), cost(cost), rev(rev) { }
};
bool operator < (const Edge &e, const Edge &f) {
  return e.cost != f.cost ? e.cost > f.cost : // !!INVERSE!!
    e.src != f.src ? e.src < f.src : e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;

typedef vector<Weight> Array;
typedef vector<Array> Matrix;

void add_edge(Graph &g, int s, int d, Weight cap, Weight cost) {
  g[s].push_back(Edge(s,d,cap,cost));
  g[d].push_back(Edge(d,s,0,-cost));
}

#define RESIDUE(u,v) (capacity[u][v] - flow[u][v])
#define RCOST(u,v) (cost[u][v] + h[u] - h[v])

// Dijkstra
pair<Weight, Weight> minimumCostFlow(const Graph &g, int s, int t) {
  const int n = g.size();
  Matrix capacity(n, Array(n)), cost(n, Array(n)), flow(n, Array(n));
  REP(u,n) FOR(e,g[u]) {
    capacity[e->src][e->dst] += e->capacity;
    cost[e->src][e->dst] += e->cost;
  }
  pair<Weight, Weight> total; // (cost, flow)
  vector<Weight> h(n, INF);
  h[s] = 0;
  // ベルマンフォードでポテンシャルを求めて負辺に対応
  REP(k, n) REP(i, n) FOR(e,g[i]) if (capacity[e->src][e->dst])
    h[e->dst] = min(h[e->dst], h[e->src] + cost[e->src][e->dst]);
  
  for (Weight F = INF; F > 0; ) { // residual flow
    vector<Weight> d(n, INF); d[s] = 0;
    vector<int> p(n, -1);
    priority_queue<Edge> Q;
    for (Q.push(Edge(-2, s, 0, 0)); !Q.empty(); ) {
      Edge e = Q.top(); Q.pop();
      if (p[e.dst] != -1) continue;
      p[e.dst] = e.src;
      FOR(f, g[e.dst]) if (RESIDUE(f->src, f->dst) > 0) {
        if (d[f->dst] > d[f->src] + RCOST(f->src, f->dst)) {
          d[f->dst] = d[f->src] + RCOST(f->src, f->dst);
          Q.push( Edge(f->src, f->dst, 0, d[f->dst]) );
        }
      }
    }
    if (p[t] == -1) break;    
    Weight f = F;
    for (int u = t; u != s; u = p[u])
      f = min(f, RESIDUE(p[u], u));
    for (int u = t; u != s; u = p[u]) {
      total.first += f * cost[p[u]][u];
      flow[p[u]][u] += f; flow[u][p[u]] -= f;
    }
    F -= f;
    total.second += f;
    REP(u, n) if (h[u] != INF) h[u] += d[u]; // ifいらない？
  }
  return total;
}

struct BYDOL {
  int x,y,p,q,r,s;
  P point;
  void in(){
    cin>>x>>y>>p>>q>>r>>s;
    point = P(x,y);
  }
};

C circle[100];
int o;

#define SOURCE n+m
#define SINK n+m+1
#define FRIEND(i) i
#define ENEMY(i) n+i

bool isVisible(P p, P q, BYDOL *A, int n, int nomit, BYDOL *B, int m, int momit, int oomit) {
  L l(p,q);
  REP(i,n) {
    if (intersectSP(l,A[i].point)) {
      if (nomit == i && (abs(l[0]-A[i].point) < EPS || abs(l[1]-A[i].point) < EPS)) continue;
      return 0;
    }
  }
  REP(i,m) {
    if (momit == i) continue;
    if (intersectSP(l,B[i].point)) return 0;
  }
  REP(i,o) {
    if (oomit == i) continue;
    if (distanceSP(l,circle[i].p) < circle[i].r-EPS) return 0;
  }
  return 1;
}

int solve(BYDOL *A, int n, BYDOL *B, int m) {
  Graph g(n+m+2);
  REP(i,n) add_edge(g, SOURCE, FRIEND(i), A[i].q, 0);
  REP(i,m) add_edge(g, ENEMY(i), SINK, 1, -B[i].s);
  REP(i,n) {
    REP(j,m) {
      if (isVisible(A[i].point, B[j].point, A, n, i, B, m, j, -1) &&
          abs(A[i].point - B[j].point) <= A[i].p+EPS) {
        // direct
        add_edge(g, FRIEND(i), ENEMY(j), 1, 0);
        continue;
      }
      if (A[i].r == 1) {
        // reflect
        REP(k,o) {
          L l(A[i].point,B[j].point);
          if (distanceSP(l, circle[k].p) <= circle[k].r + EPS) continue;
          P refl = reflectPoint(A[i].point, B[j].point, circle[k]);
          if (isVisible(A[i].point, refl, A, n, i, B, m, j, k) &&
              isVisible(refl, B[j].point, A, n, i, B, m, j, k) &&
              abs(A[i].point - refl) + abs(B[j].point - refl) <= A[i].p + EPS) {
            add_edge(g, FRIEND(i), ENEMY(j), 1, 0);
            break;
          }
        }
      }
    }
  }
  return -minimumCostFlow(g, SOURCE, SINK).first;
}

BYDOL A[100], B[100];

int main() {
  int n,m;
  while(cin >> n >> m >> o) {
    REP(i,n) A[i].in();
    REP(i,m) B[i].in();
    REP(i,o) {
      int x,y,r;
      cin >> x >> y >> r;
      circle[i] = C(P(x,y),r);
    }
    int r1 = solve(A,n,B,m);
    int r2 = solve(B,m,A,n);
    cout << r1 << " " << r2 << endl;
    if (r1 > r2) puts("win");
    else if (r1 == r2) puts("draw");
    else puts("lose");
  }
  
}

Measured memory_bytes: 1492