import java.util.Scanner;

/**
 *
 * @author tym3
 */
public class Horsemeet {
    static final int N = 8;
    static final int[][] JMP = {
        {-1,-2},{-1,+2},{+1,-2},{+1,+2},
        {-2,-1},{-2,+1},{+2,-1},{+2,+1},
    };
    
    static class Board {
        double[][] p = new double[N][N];
        
        Board copy() {
            Board b = new Board();
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    b.setP(i, j, this.getP(i, j));
                }
            }
            return b;
        }
        
        double getP(int i, int j) {
            return onBoard(i, j) ? p[i][j] : 0;
        }
        
        void setP(int i, int j, double value) {
            if (onBoard(i, j))
                p[i][j] = value;
        }
        
        void addP(int i, int j, double value) {
            if (onBoard(i, j))
                p[i][j] += value;
        }
        
        void mulP(int i, int j, double value) {
            if (onBoard(i, j))
                p[i][j] *= value;
        }
        
        boolean onBoard(int i, int j) {
            return i >= 0 && j >= 0 && i < N && j < N;
        }
    }
    
    static class Turn {
        Board white, black;
        double p_w_wins = 0.0;
        double p_b_wins = 0.0;
        
        @Override 
        public String toString() {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    String x = String.valueOf((int)(white.getP(i, j) * 100));
                    while (x.length() < 3) {
                        x = " " + x;
                    }
                    sb.append(x).append(" ");
                }
                sb.append(" | ");
                for (int j = 0; j < N; ++j) {
                    String x = String.valueOf((int)(black.getP(i, j) * 100));
                    while (x.length() < 3) {
                        x = " " + x;
                    }
                    sb.append(x).append(" ");
                }
                sb.append("\n");
            }
            return sb.toString();
        }
        
        Turn(Board w, Board b) {
            this.white = w;
            this.black = b;
        }
        
        Turn next() {
            Board w1 = white,       b1 = black;
            Board w2 = new Board(), b2 = new Board();
            
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    double w_ij = w1.getP(i, j);
                    
                    // nOB = how many jumps end on-board
                    int nOB = 0;
                    for (int k = 0; k < JMP.length; ++k) {
                        int i2 = i + JMP[k][0];
                        int j2 = j + JMP[k][1];
                        nOB += w1.onBoard(i2, j2) ? 1 : 0;
                    }
                    
                    for (int k = 0; k < JMP.length; ++k) {
                        int i2 = i + JMP[k][0];
                        int j2 = j + JMP[k][1];
                        w2.addP(i2, j2, w_ij / nOB);
                    }
                }
            }
            
            p_w_wins = 0.0;
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    double w2_ij = w2.getP(i, j);
                    double b1_ij = b1.getP(i, j);
                    p_w_wins += w2_ij * b1_ij;
                    w2.mulP(i, j, 1.0 - b1_ij);
                }
            }
            
            // simulate black
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    double b_ij = b1.getP(i, j);
                    
                    // nOB = how many jumps end on-board
                    int nOB = 0;
                    for (int k = 0; k < JMP.length; ++k) {
                        int i2 = i + JMP[k][0];
                        int j2 = j + JMP[k][1];
                        nOB += b1.onBoard(i2, j2) ? 1 : 0;
                    }
                    
                    for (int k = 0; k < JMP.length; ++k) {
                        int i2 = i + JMP[k][0];
                        int j2 = j + JMP[k][1];
                        b2.addP(i2, j2, b_ij / nOB);
                    }
                }
            }
            
            p_b_wins = 0.0;
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    double b2_ij = b2.getP(i, j);
                    double w2_ij = w2.getP(i, j);
                    p_b_wins += b2_ij * w2_ij;
                    b2.mulP(i, j, 1.0 - w2_ij);
                }
            }
            
            return new Turn(w2, b2);
        }
        
        double whiteWins() {
            return p_w_wins;
        }
        
        double blackWins() {
            return p_b_wins;
        }
        
        double draw() {
            return 1.0 - whiteWins() - blackWins();
        }
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        int wx = sc.nextInt() - 1;
        int wy = sc.nextInt() - 1;
        int bx = sc.nextInt() - 1;
        int by = sc.nextInt() - 1;
        
        Turn t = new Turn(new Board(), new Board());
        t.white.setP(wx, wy, 1.0);
        t.black.setP(bx, by, 1.0);
        double w = 0.0, b = 0.0;
        for (int k = 0; k < 200; ++k) {
            Turn t0 = t;
            t = t.next();
            w += t0.whiteWins();
            b += t0.blackWins();
        }
        
        String s;
        if (Math.abs(b - w) < 0.000001) {
            s = "draw";
        } else if (w > b) {
            s = "white";
        } else {
            s = "black";
        }
        System.out.println(s);
    }
    
}