#include <bits/stdc++.h>
using namespace std;
const string COLORS[2] = {"WHITE", "BLACK"};
const int INF = 1e9 + 5;
const int DIRS = 8;
const int DR[] = {-2, -2, -1, -1, +1, +1, +2, +2};
const int DC[] = {-1, +1, -2, +2, -2, +2, -1, +1};
int N, M;
bool valid(int r, int c) { return 1 <= r && r <= N && 1 <= c && c <= M; }
void bfs_check(queue<pair<int, int>> &q, queue<pair<int, int>> &next_q,
               vector<vector<int>> &dist,
               vector<vector<pair<int, int>>> &previous, int r, int c,
               int current_dist, int add, int from_r, int from_c) {
  assert(0 <= add && add <= 1);
  if (current_dist < dist[r][c]) {
    dist[r][c] = current_dist;
    previous[r][c] = {from_r, from_c};
    (add == 0 ? q : next_q).emplace(r, c);
  }
}
void grid_bfs(int source_r, int source_c, vector<vector<int>> &dist,
              vector<vector<pair<int, int>>> &previous) {
  if (N == 0 || M == 0) return;
  queue<pair<int, int>> q, next_q;
  dist.assign(N + 2, vector<int>(M + 2, INF));
  previous.assign(N + 2, vector<pair<int, int>>(M + 2, {-1, -1}));
  bfs_check(q, next_q, dist, previous, source_r, source_c, 0, 0, -1, -1);
  int level = 0;
  while (!q.empty() || !next_q.empty()) {
    while (!q.empty()) {
      pair<int, int> top = q.front();
      q.pop();
      int r = top.first, c = top.second;
      if (level > dist[r][c]) continue;
      for (int dir = 0; dir < DIRS; dir++) {
        int nr = r + DR[dir];
        int nc = c + DC[dir];
        if (valid(nr, nc))
          bfs_check(q, next_q, dist, previous, nr, nc, dist[r][c] + 1, 1, r, c);
      }
    }
    swap(q, next_q);
    level++;
  }
}
vector<vector<int>> dist[2];
vector<vector<pair<int, int>>> previous[2];
void output(int r, int c) { cout << r << ' ' << c << endl; }
int winner(int R[2], int C[2], int turn) {
  int right = turn, wrong = 1 - turn;
  if ((R[0] + C[0]) % 2 == (R[1] + C[1]) % 2) swap(right, wrong);
  int wrong_to_wrong = dist[wrong][R[wrong]][C[wrong]];
  int right_to_right = dist[right][R[right]][C[right]] + (wrong == 0 ? 1 : 0);
  int right_to_wrong = dist[wrong][R[right]][C[right]] - (wrong == 1 ? 1 : 0);
  if (wrong_to_wrong < min(right_to_right, right_to_wrong)) return wrong;
  return right;
}
int main() {
  ios::sync_with_stdio(false);
  int R[2], C[2];
  cin >> N >> M >> R[0] >> C[0] >> R[1] >> C[1];
  grid_bfs(N / 2, M / 2, dist[0], previous[0]);
  grid_bfs(N / 2 + 1, M / 2, dist[1], previous[1]);
  int me = winner(R, C, 0);
  int other = 1 - me;
  cout << COLORS[me] << endl;
  for (int turn = 0; dist[me][R[me]][C[me]] > 0; turn = 1 - turn) {
    if (turn != me) {
      cin >> R[other] >> C[other];
      continue;
    }
    int best_r = 0, best_c = 0;
    for (int dir = 0; dir < DIRS; dir++) {
      int nr = R[me] + DR[dir];
      int nc = C[me] + DC[dir];
      if (valid(nr, nc)) {
        if (nr == R[other] && nc == C[other]) {
          output(nr, nc);
          return 0;
        }
        swap(R[me], nr);
        swap(C[me], nc);
        if (winner(R, C, other) == me &&
            dist[me][nr][nc] < dist[me][best_r][best_c]) {
          best_r = R[me];
          best_c = C[me];
        }
        swap(R[me], nr);
        swap(C[me], nc);
      }
    }
    output(best_r, best_c);
    R[me] = best_r;
    C[me] = best_c;
  }
}
