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

using namespace std;

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

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

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

    Graph G;

    MinCostFlow(int N) : G(N) {}

    // from から to へ向かう容量cap, 費用costの辺を追加
    void add_edge(int src, int dst, int cap, int cost){
        G[src].push_back(Edge(dst, cap, cost, G[dst].size()));
        G[dst].push_back(Edge(src, 0, -cost, G[src].size() - 1));
    }

    // 頂点sから頂点tへの流量fの最小費用流を求める
    // 流せない場合は-1を返す
    int min_cost_flow(int s, int t, int f){
        int V = G.size();
        vector<int> h(V);
        vector<int> prevv(V), preve(V);
        int res = 0;
        while(f > 0){
            // dijkstraでhを更新する (負の辺がある場合は使えない!)
            priority_queue<P, vector<P>, greater<P>> que;
            vector<int> dist(V, INF);
            dist[s] = 0;
            que.push(P(0, s));

            while(!que.empty()){
                P p = que.top(); que.pop();
                int v = p.second;
                if(dist[v] < p.first) continue;
                for(int i = 0; i < G[v].size(); i++){
                    Edge& e = G[v][i];
                    int ndist = dist[v] + e.cost + h[v] - h[e.dst];
                    if(e.cap > 0 && dist[e.dst] > ndist){
                        dist[e.dst] = ndist;
                        prevv[e.dst] = v;
                        preve[e.dst] = i;
                        que.push(P(ndist, e.dst));
                    }
                }
            }

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

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

// --- 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;
    MinCostFlow solver(SINK + 1);
    solver.add_edge(SOURCE, SINK, solver.INF, 0);
    for(int i = 0; i < red.size(); i++){
        solver.add_edge(SOURCE, i, red[i].bull, 0);
    }
    for(int j = 0; j < blue.size(); j++){
        solver.add_edge(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) solver.add_edge(i, j + N, 1, 0);
        }
    }
    int res = solver.min_cost_flow(SOURCE, SINK, solver.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: 1404