#include <cstdio>
#include <iostream>
#include <cmath>

#define N 8
using namespace std;

double white_now[N][N];
double black_now[N][N];

int possible_moves[N][N];

double white_prob = 0;
double black_prob = 0;

bool inworld(int x) {
    return x >= 0 && x < 8;
}

bool inworld(int x, int y) {
    return inworld(x) && inworld(y);
}

int count_positions(int x, int y) {
    int count = 0;

    if (inworld(x + 1) && inworld(y + 2)) ++count;
    if (inworld(x + 2) && inworld(y + 1)) ++count;
    if (inworld(x + 2) && inworld(y - 1)) ++count;
    if (inworld(x + 1) && inworld(y - 2)) ++count;
    if (inworld(x - 1) && inworld(y - 2)) ++count;
    if (inworld(x - 2) && inworld(y - 1)) ++count;
    if (inworld(x  -2) && inworld(y + 1)) ++count;
    if (inworld(x - 1) && inworld(y + 2)) ++count;

    return count;
}

void count_possible_moves() {
    for (int y = 0; y<N; y++) {
        for (int x = 0; x<N; x++) {
            possible_moves[x][y] = count_positions(x, y);
        }
    }
}

void set_to_zero(double array[8][8]) {
    for (int y = 0; y<N; y++) {
        for (int x = 0; x<N; x++) {
            array[x][y] = 0;
        }
    }
}

void add_prob(double array[8][8], double prob, int x, int y) {
    if (x < 0 || x >= 8 || y < 0 || y >= 8) {
        return;
    }

    if (inworld(x + 1) && inworld(y + 2)) array[x+1][y+2] += prob;
    if (inworld(x + 2) && inworld(y + 1)) array[x+2][y+1] += prob;
    if (inworld(x + 2) && inworld(y - 1)) array[x+2][y-1] += prob;
    if (inworld(x + 1) && inworld(y - 2)) array[x+1][y-2] += prob;
    if (inworld(x - 1) && inworld(y - 2)) array[x-1][y-2] += prob;
    if (inworld(x - 2) && inworld(y - 1)) array[x-2][y-1] += prob;
    if (inworld(x  -2) && inworld(y + 1)) array[x-2][y+1] += prob;
    if (inworld(x - 1) && inworld(y + 2)) array[x-1][y+2] += prob;
}



void step(double now[8][8]) {
    double next[N][N];

    set_to_zero(next);

    for (int y = 0; y<N; y++) {
        for (int x = 0; x<N; x++) {
            add_prob(next, now[x][y] / possible_moves[x][y], x, y);
        }
    }

    for (int y = 0; y<N; y++) {
        for (int x = 0; x<N; x++) {
            now[x][y] = next[x][y];
        }
    }
}

void recalc_probabilities(double on_turn[8][8], double other[8][8], double& on_turn_prob) {
    for (int y = 0; y<N; y++) {
        for (int x = 0; x<N; x++) {
            double prob = on_turn[y][x] * other[y][x];
            on_turn_prob += prob;
            on_turn[y][x] -= prob;
            other[y][x] -= prob;
        }
    }
}



int main() {
    int A, B, C, D;
    scanf("%d %d", &A, &B);
    scanf("%d %d", &C, &D);

    for (int y = 0; y<N; y++) {
        for (int x = 0; x<N; x++) {
            white_now[x][y] = 0;
            black_now[x][y] = 0;
        }
    }

    white_now[A-1][B-1] = 1;
    black_now[C-1][D-1] = 1;

    count_possible_moves();

    for (int i = 0; i < 20000; ++i) {
        step(white_now);
        recalc_probabilities(white_now, black_now, white_prob);
        step(black_now);
        recalc_probabilities(black_now, white_now, black_prob);
    }

    if (abs(white_prob - black_prob) < 1e-6) {
        cout << "draw\n";
    } else if (white_prob > black_prob) {
        cout << "white\n";
    } else {
        cout << "black\n";
    }


    return 0;
}