#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)

using namespace std;

// --- min_cost_flow --- 
typedef pair<int, int> P; // (最短距離, 頂点の番号)
const int INF = 100000000; // infinity

struct Edge{
    int to, cap, cost, rev;
    Edge() {}
    Edge(int t, int c, int cs, int r) : 
        to(t), cap(c), cost(cs), rev(r) {}
};

typedef vector<Edge> Node;
typedef vector<Node> Graph;

// from から to へ向かう容量cap, 費用costの辺を追加
void add_edge(Graph& G, 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(Graph G, int s, int t, int f){
    int V = G.size();
    vector<int> prevv(V), preve(V);
    int res = 0;
    //REP(from, G.size()) REP(i, G[from].size()) printf("%d -> %d %d %d\n", from, G[from][i].to, G[from][i].cap, G[from][i].cost);
    while(f > 0){
        vector<int> dist(V, INF);
        dist[s] = 0;

        for(int iter = 0; iter < V; iter++){
            bool update = false;
            for(int from = 0; from < V; from++){
                if(dist[from] == INF) continue;
                for(int i = 0; i < G[from].size(); i++){
                    const Edge& e = G[from][i];
                    if(e.cap > 0 && dist[e.to] > dist[from] + e.cost){
                        dist[e.to] = dist[from] + e.cost;
                        prevv[e.to] = from;
                        preve[e.to] = i;
                        update = true;
                    }
                }
            }
            if(!update) break;
            assert(iter + 1 != G.size());
        }

        if(dist[t] == INF){
            // これ以上流せない
            assert(false);
        }

        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;
}
// --- min_cost_flow ---

// --- geometory --- 
const double EPS = 1e-8;
int sign(double a){
    if(a > EPS) return +1;
    if(a < -EPS) return -1;
    return 0;
}
typedef complex<double> Point;
double angle(Point a, Point b){
    double res = arg(conj(a) * b);
    if(abs(res) < EPS) res = 0;
    if(res < 0) res = res + 2 * M_PI;
    return res;
}
double dot(Point a, Point b){
    return real(conj(a) * b);
}
double cross(Point a, Point b){
    return imag(conj(a) * b);
}
int ccw(Point a, Point b, Point c) {
    b -= a; c -= a;
    double len = abs(b) * abs(c); // 速さが気になるときは1にする
    if (cross(b, c) > +len * EPS)   return +1; // 反時計回り
    if (cross(b, c) < -len * EPS)   return -1; // 時計回り
    if (dot(b, c) < 0)     return +2; // c--a--b の順番で一直線上
    if (norm(b) < norm(c)) return -2; // a--b--c の順番で一直線上
    return 0;                         // 点が線分ab上にある
}
struct Line : public vector<Point> {
    Line(const Point& a, const Point& b) {
        push_back(a); push_back(b);
    }
    Point vector() const {
        return back() - front();
    }
};
Point projection(Line l, Point p){
    double t = dot(p - l[0], l.vector()) / norm(l.vector());
    return l[0] + t * l.vector();
}
bool intersectSP(Line s, Point p) {
    return ccw(s[0], s[1], p) == 0;
}
double distanceSP(Line s, Point p){
    Point r = projection(s, p);
    if(intersectSP(s, r)) return abs(r - p); // 垂線が線分に交わるとき
    return min(abs(s[0] - p), abs(s[1] - p));
}
struct Circle {
    Point p;
    double r;
    Circle() {}
    Circle(Point p_, double r_) : p(p_), r(r_) {}
};
enum{ OUT, ON, IN };
int contains(const Circle& C, const Point& p){
    double d = abs(C.p - p);
    if(sign(d - C.r) > 0) return OUT;
    if(sign(d - C.r) == 0) return ON;
    return IN;
}

bool intersectCS(const Circle& C, const Line& l){
    int b[2];
    for(int i = 0; i < 2; i++){
        b[i] = contains(C, l[i]);
    }
    if(b[0] > b[1]) swap(b[0], b[1]);

    // (OUT, OUT) (OUT, ON) (OUT, IN) (ON, ON) (ON, IN) (IN, IN) の6通り
    if(b[0] == OUT && b[1] == IN) return true;
    if(b[0] == IN && b[1] == IN) return false;
    if(b[0] == ON) return true; // (接するとき) 
    double d = distanceSP(l, C.p);
    if(sign(d - C.r) < 0) return true;
    if(sign(d - C.r) == 0) return false; // (接するとき)
    if(sign(d - C.r) > 0) return false;
    assert(false);
}
const double ZOOM = 5;
const double EDGE = 10;
void draw(Line l){
    REP(i, 2){
        l[i] *= ZOOM;
    }
    fprintf(stderr, "line(%f, %f, %f, %f);\n", l[0].real() + EDGE, l[0].imag(), l[1].real() + EDGE, l[1].imag());
}
void draw(Circle C){
    C.p *= ZOOM;
    C.r *= ZOOM;
    fprintf(stderr, "circle(%f, %f, %f);\n", C.p.real() + EDGE, C.p.imag(), C.r);
}
// --- geometory ---

struct BYDOL{
    Point p;
    double len;
    int bull;
    int refl;
    int score;
};
int solve(const vector<BYDOL>& red,  const vector<BYDOL>& blue, const vector<Circle>& walls){
    int N = red.size();
    int M = blue.size();
    const int SOURCE = N + M;
    const int SINK = SOURCE + 1;
    Graph G(SINK + 1);
    add_edge(G, SOURCE, SINK, INF, 0);
    for(int i = 0; i < red.size(); i++){
        add_edge(G, SOURCE, i, red[i].bull, 0);
    }
    for(int j = 0; j < blue.size(); j++){
        add_edge(G, j + N, SINK, 1, -blue[j].score);
    }
    for(int i = 0; i < red.size(); i++){
        for(int j = 0; j < blue.size(); j++){
            const BYDOL& r = red[i];
            const BYDOL& b = blue[j];
            bool arrive = false;
            // one-line
            Line s(r.p, b.p);
            {
                bool ok = true;
                if(abs(s.vector()) > r.len + EPS) ok = false;
                for(int k = 0; k < walls.size(); k++){
                    const Circle& c = walls[k];
                    if(intersectCS(c, s)) ok = false;
                }
                for(int k = 0; k < blue.size(); k++) if(j != k) {
                    if(intersectSP(s, blue[k].p)) ok = false;
                }
                for(int k = 0; k < red.size(); k++) if(i != k) {
                    if(intersectSP(s, red[k].p)) ok = false;
                }

                if(ok){
                    arrive = true;
                }
            }
            // two-line
            if(r.refl){
                for(int k = 0; k < walls.size(); k++){
                    const Circle& c = walls[k];
                    if(intersectCS(c, s)) continue;
                    if(contains(c, r.p) != OUT) continue;
                    if(contains(c, b.p) != OUT) continue;
                    double lb = 0, ub = 1;
                    REP(iter, 100){
                        double mid = (lb + ub) / 2;
                        Point p = r.p + (b.p - r.p) * mid;
                        Point t = c.p + (p - c.p) / abs(p - c.p) * c.r;
                        double th1 = (ccw(c.p, r.p, b.p) > 0 ? angle(r.p - t, t - c.p) : angle(t - c.p, r.p - t));
                        double th2 = (ccw(c.p, r.p, b.p) > 0 ? angle(t - c.p, b.p - t) : angle(b.p - t, t - c.p));
                        //printf("%f %f\n", th1, th2);
                        if(th1 < th2){
                            lb = mid;
                        }else{
                            ub = mid;
                        }
                    }
                    Point p = r.p + (b.p - r.p) * lb;
                    Point t = c.p + (p - c.p) / abs(p - c.p) * c.r;
                    Line s1(r.p, t);
                    Line s2(t, b.p);
                    double th1 = (ccw(c.p, r.p, b.p) > 0 ? angle(r.p - t, t - c.p) : angle(t - c.p, r.p - t));
                    double th2 = (ccw(c.p, r.p, b.p) > 0 ? angle(t - c.p, b.p - t) : angle(b.p - t, t - c.p));
                    bool ok = true;
                    if(abs(th1 - th2) > EPS){
                        printf("lb: %f\n", lb);
                        printf("r.p: (%f, %f)\n", r.p.real(), r.p.imag());
                        printf("b.p: (%f, %f)\n", b.p.real(), b.p.imag());
                        printf("c.p: (%f, %f)\n", c.p.real(), c.p.imag());
                        printf("c.l: %f\n", c.r);
                        printf("t:   (%f, %f)\n", t.real(), t.imag());
                        printf("th1:%f th2:%f\n", th1, th2);
                        assert(false);
                    }
                    if(intersectSP(s2, r.p)) ok = false;
                    if(abs(s1.vector()) + abs(s2.vector()) > r.len + EPS) ok = false;
                    for(int k2 = 0; k2 < walls.size(); k2++) {
                        const Circle& c2 = walls[k2];
                        if(intersectCS(c2, s1)) ok = false;
                        if(intersectCS(c2, s2)) ok = false;
                    }
                    for(int k2 = 0; k2 < blue.size(); k2++) if(j != k2){
                        if(intersectSP(s1, blue[k2].p)) ok = false;
                        if(intersectSP(s2, blue[k2].p)) ok = false;
                    }
                    for(int k2 = 0; k2 < red.size(); k2++) if(i != k2){
                        if(intersectSP(s1, red[k2].p)) ok = false;
                        if(intersectSP(s2, red[k2].p)) ok = false;
                    }
                    if(ok){
                        arrive = true;
                    }
                }
            }
            if(arrive) add_edge(G, i, j + N, 1, 0);
        }
    }
    int res = min_cost_flow(G, SOURCE, SINK, INF);
    return -res;
}
int main(){
    int N, M, O;
    while(cin >> N >> M >> O){
        srand(time(NULL));
        vector<BYDOL> red(N), blue(M);
        REP(i, N) {
            BYDOL& r = red[i];
            double x, y;
            cin >> x >> y;
            r.p = Point(x, y);
            cin >> r.len >> r.bull >> r.refl >> r.score;
        }

        REP(i, M) {
            BYDOL& b = blue[i];
            double x, y;
            cin >> x >> y;
            b.p = Point(x, y);
            cin >> b.len >> b.bull >> b.refl >> b.score;
        }
        vector<Circle> walls(O);
        REP(i, O){
            double x, y;
            cin >> x >> y;
            walls[i].p = Point(x, y);
            cin >> walls[i].r;
        }
        /*
        REP(i, 500){
            BYDOL r;
            r.p = Point(rand() % 100, rand() % 100);
            r.len = rand() % 100, r.bull = 5, r.refl = 1, r.score = 100;
            bool ok = true;
            REP(j, O) if(contains(walls[j], r.p) != OUT) ok = false;
            if(!ok) continue;
            if(i % 2 == 0) red.push_back(r);
            else blue.push_back(r);
        }
        */

        int rpoint = solve(red, blue, walls);
        int bpoint = solve(blue, red, walls);
        string result = (rpoint > bpoint ? "win" : rpoint < bpoint ? "lose" : "draw");
        cout << rpoint << " " << bpoint << endl;
        cout << result << endl;
    }
    return 0;
}

Measured memory_bytes: 1412