#include <bits/stdc++.h>
using namespace std;
template <typename T>
vector<T>& operator--(vector<T>& v) {
  for (auto& i : v) --i;
  return v;
}
template <typename T>
vector<T>& operator++(vector<T>& v) {
  for (auto& i : v) ++i;
  return v;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
  for (auto& i : v) is >> i;
  return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
  for (auto& i : v) os << i << ' ';
  return os;
}
template <typename T, typename U>
pair<T, U>& operator--(pair<T, U>& p) {
  --p.first;
  --p.second;
  return p;
}
template <typename T, typename U>
pair<T, U>& operator++(pair<T, U>& p) {
  ++p.first;
  ++p.second;
  return p;
}
template <typename T, typename U>
istream& operator>>(istream& is, pair<T, U>& p) {
  is >> p.first >> p.second;
  return is;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, pair<T, U>& p) {
  os << p.first << ' ' << p.second;
  return os;
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
  return make_pair(a.first - b.first, a.second - b.second);
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
  return make_pair(a.first + b.first, a.second + b.second);
}
template <typename T, typename U>
void umin(T& a, U b) {
  if (a > b) a = b;
}
template <typename T, typename U>
void umax(T& a, U b) {
  if (a < b) a = b;
}
const vector<pair<int, int>> D = {{-2, -1}, {-2, 1},  {2, -1}, {2, 1},
                                  {-1, 2},  {-1, -2}, {1, 2},  {1, -2}};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int n, m;
  cin >> n >> m;
  auto get_dists = [&](int x, int y) {
    vector<vector<int>> d(n, vector<int>(m, 1e9));
    d[x][y] = 0;
    queue<pair<int, int>> q;
    q.emplace(x, y);
    while (!q.empty()) {
      auto [x, y] = q.front();
      q.pop();
      for (auto [dx, dy] : D) {
        int x1 = x + dx;
        int y1 = y + dy;
        if (x1 < 0 || y1 < 0 || x1 >= n || y1 >= m) continue;
        if (d[x1][y1] < d[x][y] + 1) continue;
        d[x1][y1] = d[x][y] + 1;
        q.emplace(x1, y1);
      }
    }
    return d;
  };
  auto dist_white = get_dists(n / 2 - 1, m / 2 - 1);
  auto dist_black = get_dists(n / 2, m / 2 - 1);
  pair<int, int> pw, push_back;
  cin >> pw >> push_back;
  pw.first--;
  pw.second--;
  push_back.first--;
  push_back.second--;
  pair<int, int> needb = {n / 2, m / 2 - 1};
  pair<int, int> needw = {n / 2 - 1, m / 2 - 1};
  auto col = [&](pair<int, int> p) { return (p.first + p.second) % 2; };
  auto covered = [&](pair<int, int> a, pair<int, int> b) {
    return abs(a.first - b.first) + abs(a.second - b.second) == 3 &&
           a.first != b.first && a.second != b.second;
  };
  auto manh = [&](pair<int, int> a, pair<int, int> b) {
    return abs(a.first - b.first) + abs(a.second - b.second);
  };
  auto get_move = [&](pair<int, int> me, pair<int, int> he,
                      const vector<vector<int>>& target_dists) {
    if (covered(me, he)) {
      cout << he.first + 1 << ' ' << he.second + 1 << endl;
      exit(0);
    }
    pair<int, int> best = {-1, -1};
    for (auto [dx, dy] : D) {
      int x1 = me.first + dx;
      int y1 = me.second + dy;
      if (x1 < 0 || y1 < 0 || x1 >= n || y1 >= m) continue;
      if (covered({x1, y1}, he)) continue;
      if (best.first == -1) {
        best = {x1, y1};
        continue;
      }
      if (target_dists[best.first][best.second] < target_dists[x1][y1])
        continue;
      best = {x1, y1};
    }
    assert(best.first != -1);
    return best;
  };
  auto start_black = [&]() {
    cout << "BLACK" << endl;
    cin >> pw;
    --pw.first;
    --pw.second;
  };
  auto start_white = [&]() { cout << "WHITE" << endl; };
  auto play_black = [&](const vector<vector<int>>& targetd) {
    while (targetd[push_back.first][push_back.second] != 0) {
      push_back = get_move(push_back, pw, targetd);
      cout << push_back.first + 1 << ' ' << push_back.second + 1 << endl;
      if (push_back == needb) {
        exit(0);
      }
      assert(push_back != pw);
      cin >> pw;
      --pw.first;
      --pw.second;
      if (targetd[push_back.first][push_back.second] == 0) break;
    }
  };
  auto play_white = [&](const vector<vector<int>>& targetd) {
    while (targetd[pw.first][pw.second] != 0) {
      pw = get_move(pw, push_back, targetd);
      cout << pw.first + 1 << ' ' << pw.second + 1 << endl;
      if (pw == needw) {
        exit(0);
      }
      assert(pw != push_back);
      cin >> push_back;
      --push_back.first;
      --push_back.second;
      if (targetd[pw.first][pw.second] == 0) break;
    }
  };
  auto mark_path = [&](const vector<vector<int>>& d, pair<int, int> p) {
    vector<pair<int, int>> cur = {p};
    int curd = d[p.first][p.second];
    map<int, vector<pair<int, int>>> res;
    res[curd].push_back(p);
    while (curd != 0) {
      vector<pair<int, int>> next;
      for (auto [x, y] : cur) {
        for (auto [dx, dy] : D) {
          if (x + dx < 0 || y + dy < 0 || x + dx >= n || y + dy >= m) continue;
          if (d[x + dx][y + dy] != curd - 1) continue;
          42;
          next.emplace_back(x + dx, y + dy);
        }
      }
      sort(next.begin(), next.end());
      next.erase(unique(next.begin(), next.end()), next.end());
      --curd;
      res[curd] = next;
      swap(cur, next);
    }
    return res;
  };
  42;
  42;
  if (col(pw) == col(push_back)) {
    if (dist_black[push_back.first][push_back.second] <
        dist_white[pw.first][pw.second]) {
      start_black();
      play_black(dist_black);
      return 0;
    } else if (dist_white[push_back.first][push_back.second] <=
               dist_white[pw.first][pw.second] + 1) {
      start_black();
      play_black(dist_white);
      play_black(dist_black);
      return 0;
    } else {
      42;
      start_white();
      play_white(dist_white);
      return 0;
    }
  } else {
    if (dist_black[push_back.first][push_back.second] >=
        dist_white[pw.first][pw.second]) {
      start_white();
      play_white(dist_white);
      return 0;
    } else if (dist_black[push_back.first][push_back.second] + 1 >=
               dist_black[pw.first][pw.second]) {
      start_white();
      play_white(dist_black);
      play_white(dist_white);
      return 0;
    } else {
      start_black();
      play_black(dist_black);
      return 0;
    }
  }
  return 0;
}
