On a chessboard with a width of $n$ and a height of $n$, rows are numbered from bottom to top from $1$ to $n$, columns are numbered from left to right from $1$ to $n$. Therefore, for each cell of the chessboard, you can assign the coordinates $(r,c)$, where $r$ is the number of the row, and $c$ is the number of the column.

The white king has been sitting in a cell with $(1,1)$ coordinates for a thousand years, while the black king has been sitting in a cell with $(n,n)$ coordinates. They would have sat like that further, but suddenly a beautiful coin fell on the cell with coordinates $(x,y)$...

Each of the monarchs wanted to get it, so they decided to arrange a race according to slightly changed chess rules:

As in chess, the white king makes the first move, the black king makes the second one, the white king makes the third one, and so on. However, in this problem, kings can stand in adjacent cells or even in the same cell at the same time.

The player who reaches the coin first will win, that is to say, the player who reaches the cell with the coordinates $(x,y)$ first will win.

Let's recall that the king is such a chess piece that can move one cell in all directions, that is, if the king is in the $(a,b)$ cell, then in one move he can move from $(a,b)$ to the cells $(a + 1,b)$, $(a - 1,b)$, $(a,b + 1)$, $(a,b - 1)$, $(a + 1,b - 1)$, $(a + 1,b + 1)$, $(a - 1,b - 1)$, or $(a - 1,b + 1)$. Going outside of the field is prohibited.

Determine the color of the king, who will reach the cell with the coordinates $(x,y)$ first, if the white king moves first.


-----Input-----

The first line contains a single integer $n$ ($2 \le n \le 10^{18}$) — the length of the side of the chess field.

The second line contains two integers $x$ and $y$ ($1 \le x,y \le n$) — coordinates of the cell, where the coin fell.


-----Output-----

In a single line print the answer "White" (without quotes), if the white king will win, or "Black" (without quotes), if the black king will win.

You can print each letter in any case (upper or lower).


-----Examples-----
Input
4
2 3

Output
White
Input
5
3 5

Output
Black
Input
2
2 2

Output
Black


-----Note-----

An example of the race from the first sample where both the white king and the black king move optimally: The white king moves from the cell $(1,1)$ into the cell $(2,2)$. The black king moves form the cell $(4,4)$ into the cell $(3,3)$. The white king moves from the cell $(2,2)$ into the cell $(2,3)$. This is cell containing the coin, so the white king wins. [Image] 

An example of the race from the second sample where both the white king and the black king move optimally: The white king moves from the cell $(1,1)$ into the cell $(2,2)$. The black king moves form the cell $(5,5)$ into the cell $(4,4)$. The white king moves from the cell $(2,2)$ into the cell $(3,3)$. The black king moves from the cell $(4,4)$ into the cell $(3,5)$. This is the cell, where the coin fell, so the black king wins. [Image] 

In the third example, the coin fell in the starting cell of the black king, so the black king immediately wins. [Image]

Difficulty: EASY
Tags: Mathematics

Implementation
Expected Time Complexity: O(1)

Starter code:

Solutions:
n = int(input())
(x, y) = map(int, input().split())
print('White' if abs(1 - x) + abs(1 - y) <= abs(n - x) + abs(n - y) else 'Black')


n = int(input())
(a, b) = map(int, input().split())
print('White' if a + b - 2 <= 2 * n - a - b else 'Black')


def A(n, x, y):
	if n - x + (n - y) < x + y - 2:
		return 'Black'
	return 'White'
n = int(input())
(x, y) = [int(x) for x in input().split()]
print(A(n, x, y))


a = int(input())
(c1, c2) = map(int, input().split())
print(['White', 'Black'][max(a - c1, a - c2) < max(c1 - 1, c2 - 1)])


n = int(int(input()))
Coin = list(map(int, input().split()))
Coin[0] = Coin[0] - 1
Coin[1] = Coin[1] - 1
WhiteKing = [0, 0]
BlackKing = [n - 1, n - 1]
WTCX = WhiteKing[0] - Coin[0]
WTCY = WhiteKing[1] - Coin[1]
BTCX = BlackKing[0] - Coin[0]
BTCY = BlackKing[1] - Coin[1]
Wans = max(abs(WTCX), abs(WTCY))
Bans = max(abs(BTCX), abs(BTCY))
if Wans <= Bans:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = input().split()
(x, y) = (int(x), int(y))
if x < y:
	(x, y) = (y, x)
zbx = n - x + 1
zby = n - y + 1
if zby < x:
	print('Black')
else:
	print('White')


import sys
n = int(next(sys.stdin))
(row, col) = map(int, next(sys.stdin).split())
minimum = min(row, col)
white = minimum - 1 + max(row - minimum, col - minimum)
maximum = max(row, col)
black = n - maximum + max(maximum - row, maximum - col)
print('White' if white <= black else 'Black')


n = int(input())
(x, y) = map(int, input().split())
if n + 1 >= x + y:
	print('white')
else:
	print('black')


n = int(input())
(x, y) = map(int, input().split())
w_dist = (x - 1) ** 2 + (y - 1) ** 2
b_dist = (x - n) ** 2 + (y - n) ** 2
if w_dist <= b_dist:
	print('White')
else:
	print('Black')


def parseInt(s):
	return int(s) - 1

def e():
	n = int(input())
	coin = list(map(parseInt, input().split()))
	wk = (0, 0)
	bk = (n - 1, n - 1)
	if max(abs(wk[0] - coin[0]), abs(wk[1] - coin[1])) <= max(abs(bk[0] - coin[0]), abs(bk[1] - coin[1])):
		print('White')
	else:
		print('Black')
e()


n = int(input())
(x, y) = map(int, input().split())
if max(x, y) - 1 <= n - min(x, y):
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
(x1, y1) = (1, 1)
(x2, y2) = (n, n)
d1 = (x1 - x) ** 2 + (y1 - y) ** 2
d2 = (x2 - x) ** 2 + (y2 - y) ** 2
if d1 <= d2:
	print('White')
elif d1 > d2:
	print('Black')


n = int(input())
(a, b) = map(int, input().split())
white = max(a, b)
black = max(n - a, n - b)
if black < white - 1:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = list(map(int, input().split()))
d1 = abs(1 - x) + abs(1 - y)
d2 = abs(n - x) + abs(n - y)
if d1 == d2:
	print('White')
elif d1 > d2:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
c = 1
c1 = 0
if x > 1 and x < y:
	c = x - 1
elif y > 1:
	c = y - 1
c += abs(x - y)
if x < n and x > y:
	c1 = n - x
elif y < n:
	c1 = n - y
c1 += abs(x - y)
if c <= c1:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
white = [1, 1]
black = [n, n]
wdist = abs(x - 1) + abs(y - 1)
bdist = abs(n - x) + abs(n - y)
if wdist > bdist:
	print('Black')
elif wdist < bdist:
	print('White')
else:
	print('White')


def go():
	n = int(input())
	(x, y) = [int(i) for i in input().split(' ')]
	a = 1 + 1
	b = n + n
	c = x + y
	distance_w = c - a
	distance_b = b - c
	if distance_w == distance_b:
		return 'White'
	if distance_w < distance_b:
		return 'White'
	return 'Black'
print(go())


n = int(input())
(x, y) = map(int, input().split())
w = x + y - 2
b = 2 * n - x - y
if w <= b:
	print('White')
else:
	print('Black')


a = int(input())
(b, c) = map(int, input().split())
d = b + c
if d <= a + 1:
	print('White')
else:
	print('Black')


n = int(input())
(a, b) = map(int, input().split())
l = a - 1 + (b - 1)
k = n - a + (n - b)
if l <= k:
	print('White')
else:
	print('Black')


def test_0():
	import math
	from collections import Counter
	n = list(map(int, input().split(' ')))[0]
	(x, y) = list(map(int, input().split(' ')))
	a1 = abs(x - y)
	a2 = min(x, y) - 1
	d1 = a2 + a1
	b1 = abs(x - y)
	b2 = n - max(x, y)
	d2 = b2 + b1
	if d2 < d1:
		print('Black')
	else:
		print('White')
test_0()


n = int(input())
z = map(int, input().split())
z = tuple(z)
x = z[0]
y = z[1]
a = max(z) - 1
b = n - min(z)
if a <= b:
	print('White')
elif a > b:
	print('Black')


n = int(input())
(a, b) = list(map(int, input().split()))
result = abs(a - 1) + abs(b - 1) <= abs(n - a) + abs(n - b)
if result:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
qjw = max(abs(x - 1), abs(y - 1))
to = max(abs(x - n), abs(y - n))
if qjw <= to:
	print('White')
else:
	print('Black')


n = int(input())
(a, b) = map(int, input().split())
(c1, c2) = (0, 0)
c1 = min(a - 1, b - 1) + abs(a - b)
c2 = min(n - a, n - b) + abs(a - b)
if c1 <= c2:
	print('White')
else:
	print('Black')


def solve(n, x, y):
	w = x + y - min(x, y) - 1
	b = n - x + 1 + (n - y + 1) - min(n - x + 1, n - y + 1) - 1
	return 'White' if w <= b else 'Black'

def main():
	n = int(input())
	(x, y) = list(map(int, input().split()))
	print(solve(n, x, y))
main()


from bisect import bisect_right as br
from bisect import bisect_left as bl
from math import *

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b, x, y):
	return abs(a - x) + abs(b - y)
n = int(input())
(a, b) = map(int, input().split())
if mhd(a, b, 1, 1) <= mhd(a, b, n, n):
	print('White')
else:
	print('Black')


n = int(input())
(a, b) = [int(i) for i in input().split()]
white = a - 1 - 1 + (b - 1 - 1) + 1
black = n - a - 1 + (n - b - 1) + 1
if white <= black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
w1 = x - 1
w2 = y - 1
b1 = abs(x - n)
b2 = abs(y - n)
w = 0
b = 0
if w1 >= w2:
	w = w1
else:
	w = w2
if b1 >= b2:
	b = b1
else:
	b = b2
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(i) for i in input().split()]
d1 = abs(x - 1) + abs(y - 1)
d2 = abs(n - x) + abs(n - y)
print('White' if d1 <= d2 else 'Black')


n = int(input())
(x, y) = map(int, input().split())
print('WBhliatcek'[x + y > n + 1::2])


n = int(input())
(x, y) = [int(a) for a in input().split()]
d1 = max(x - 1, y - 1)
d2 = max(n - x, n - y)
if d1 <= d2:
	print('White')
else:
	print('Black')


n = int(input())
a = input()
a = a.split()
for i in range(len(a)):
	a[i] = int(a[i])
x = a[0] - 1
if x < 0:
	x = x * -1
y = a[0] - n
if y < 0:
	y = y * -1
xx = a[1] - 1
if xx < 0:
	xx = xx * -1
yy = a[1] - n
if yy < 0:
	yy = yy * -1
if xx + x < yy + y or xx + x == yy + y:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
c = (x - 1, y - 1)
d = (n - x, n - y)
a = max(c)
b = max(d)
if a <= b:
	print('White')
else:
	print('Black')


n = int(input())
(r, s) = map(int, input().split())
z1 = r - 1
z2 = s - 1
if z1 < z2:
	z = z1
	zx = z + (z1 - z)
else:
	z = z2
	zx = z + (z2 - z)
k1 = n - r
k2 = n - s
if k1 < k2:
	k = k1
	kx = k + (k1 - k)
else:
	k = k2
	kx = k + (k2 - k)
if z < k:
	print('White')
elif z > k:
	print('Black')
else:
	print('White')


n = int(input())
(r, c) = input().strip().split(' ')
(r, c) = [int(r), int(c)]
if r - 1 + (c - 1) > abs(n - r) + abs(n - c):
	print('Black')
else:
	print('White')


import math
n = int(input())
(x, y) = map(int, input().split())
if y > n + 1 - x:
	print('Black')
else:
	print('White')


def win():
	n = int(input())
	goal = input().split()
	x = int(goal[0]) - 1
	y = int(goal[1]) - 1
	white = max(x, y)
	black = max(n - 1 - x, n - 1 - y)
	if white <= black:
		print('White')
	else:
		print('Black')
win()


def solve():
	n = int(input())
	(x, y) = list(map(int, input().split()))
	if (x - 1) * (x - 1) + (y - 1) * (y - 1) <= (n - x) * (n - x) + (n - y) * (n - y):
		print('White')
	else:
		print('Black')
solve()


n = int(input())
(x, y) = map(int, input().split())
z = min(x, y)
k = max(x, y)
w = z - 1
b = n - k
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
white_moves = max(x - 1, y - 1)
black_moves = max(n - x, n - y)
if black_moves < white_moves:
	print('Black')
else:
	print('White')


def readint():
	return int(input())

def readline():
	return [int(c) for c in input().split()]

def main():
	n = readint()
	(row, col) = readline()
	row = n - row
	col -= 1
	if row >= col:
		print('White')
	else:
		print('Black')
main()


n = int(input())
(x, y) = map(int, input().split())
a = [x - 1, y - 1]
b = [n - x, n - y]
if x == y:
	a[0] -= 1
	a[1] -= 1
else:
	a[a.index(max(a))] -= 1
white = min(a) + (max(a) - min(a))
black = min(b) + (max(b) - min(b))
if white < black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(x) for x in input().split()]
x = n - x + 1
numW = n - x + y - 1
numB = x - 1 + n - y
if numB < numW:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
k = (x - 1 ^ 2) + (y - 1 ^ 2)
l = (n - x ^ 2) + (n - y ^ 2)
if k > l:
	print('black')
else:
	print('white')


m = int(int(input()))
a = list(map(int, input().split()))
a[0] = a[0] - 1
a[1] = a[1] - 1
wk = [0, 0]
bk = [m - 1, m - 1]
w = max(abs(wk[0] - a[0]), abs(wk[1] - a[1]))
b = max(abs(bk[0] - a[0]), abs(bk[1] - a[1]))
if w <= b:
	print('White')
else:
	print('Black')


n = input()
n = int(n)
(x, y) = input().strip().split(' ')
(x, y) = (int(x), int(y))
wx = x - 1
wy = y - 1
if wx >= wy:
	wsteps = wx
else:
	wsteps = wy
bx = n - x
by = n - y
if bx >= by:
	bsteps = bx
else:
	bsteps = by
if wsteps <= bsteps or wsteps == bsteps - 1:
	print('White')
else:
	print('Black')


import math
n = int(input())
a = input()
(x, y) = a.split()
x = int(x)
y = int(y)
d1 = x - 1 + (y - 1)
d2 = n - x + (n - y)
if d1 <= d2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
(x1, y1) = (1, 1)
(x2, y2) = (n, n)
w = max(x - x1, y - y1)
b = max(x2 - x, y2 - y)
if w <= b:
	print('WHITE')
else:
	print('BLACK')


gi = lambda : list(map(int, input().split()))
(n,) = gi()
(r, c) = gi()
print(['Black', 'White'][max(n - r, n - c) >= max(r - 1, c - 1)])


n = int(input())
(x, y) = map(int, input().split())
disx1 = abs(x - 1)
disx2 = abs(y - 1)
disy1 = abs(x - n)
disy2 = abs(y - n)
if max(disx1, disx2) < max(disy1, disy2):
	print('White')
elif disx1 + disx2 > disy1 + disy2:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = list(map(int, input().split()))

def solve(n, x, y):
	white_distance = max(x - 1, y - 1)
	black_distance = max(n - x, n - y)
	if white_distance == 0:
		return 'White'
	if black_distance == 0:
		return 'Black'
	return 'Black' if white_distance > black_distance else 'White'
print(solve(n, x, y))


(n, (x, y)) = (int(input()), map(int, input().split()))
print(('Black', 'White')[max(x - 1, y - 1) <= max(n - x, n - y)])


n = int(input())
a = []
s = input()
x = s.split()
a = [int(y) for y in x]
w = a[0] + a[1] - 2
b = 2 * n - a[0] - a[1]
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
num = x - 1 + y - 1
num2 = n - x + n - y
ans = num <= num2
if ans:
	print('White')
else:
	print('Black')


N = int(input())
(X, Y) = map(int, input().split())
dist1 = max(X - 1, Y - 1)
dist2 = max(N - X, N - Y)
if dist1 <= dist2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
white = min(x, y) - 1 + abs(x - y)
black = n - max(x, y) + abs(x - y)
if white <= black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
ma = max(x - 1, y - 1)
mb = max(n - x, n - y)
if ma <= mb:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(a) for a in input().split()]
if x > y:
	(x, y) = (y, x)
n_while = x - 1 + (y - 1 - (x - 1))
n_black = n - y + (n - x - (n - y))
if n_while > n_black:
	print('Black')
else:
	print('White')


import sys
length_of_board = int(input())
price_coordinates = tuple(map(int, input().split(' ')))
starting_point_white = (1, 1)
starting_point_black = (int(length_of_board), int(length_of_board))
white_x_diff = abs(starting_point_white[0] - price_coordinates[0])
white_y_diff = abs(starting_point_white[1] - price_coordinates[1])
white_steps = max(white_x_diff, white_y_diff)
black_x_diff = abs(starting_point_black[0] - price_coordinates[0])
black_y_diff = abs(starting_point_black[1] - price_coordinates[1])
black_steps = max(black_x_diff, black_y_diff)
if black_steps >= white_steps:
	print('White')
elif black_steps < white_steps:
	print('Black')


bk = int(input())
(dr, dc) = list(map(int, input().split()))
ws = dr - 1 + dc - 1
bs = bk - dr + bk - dc
if ws <= bs:
	print('White')
else:
	print('Black')


import math
n = int(input())
x = list(map(int, input().split()))
dist_black = n - x[0] + n - x[1]
dist_white = x[0] - 1 + x[1] - 1
if dist_black < dist_white:
	print('Black')
else:
	print('White')


def solution(l1, n):
	l1 = [x - 1 for x in l1]
	distw = max(l1)
	l1 = [n - x - 1 for x in l1]
	distb = max(l1)
	if distw > distb:
		return 'Black'
	else:
		return 'White'

def answer():
	n = int(input())
	l1 = [int(x) for x in input().split()]
	print(solution(l1, n))
answer()


from sys import stdin

def main():
	n = int(stdin.readline())
	(cx, cy) = map(int, stdin.readline().split())
	a = abs(cx - 1) + abs(cy - 1)
	b = abs(cx - n) + abs(cy - n)
	if b >= a:
		print('White')
	else:
		print('Black')
main()


print('White' if int(input()) + 1 >= sum(map(int, input().split())) else 'Black')


n = int(input())
(x, y) = (int(k) for k in input().split())
print('White' if max(x - 1, y - 1) <= max(n - x, n - y) else 'Black')


n = int(int(input()))
moneda = list(map(int, input().split()))
moneda[0] = moneda[0] - 1
moneda[1] = moneda[1] - 1
trump = [0, 0]
obunga = [n - 1, n - 1]
xxx = trump[0] - moneda[0]
xxy = trump[1] - moneda[1]
bbcx = obunga[0] - moneda[0]
bbcy = obunga[1] - moneda[1]
wSupremacy = max(abs(xxx), abs(xxy))
wSlaves = max(abs(bbcx), abs(bbcy))
if wSupremacy <= wSlaves:
	print('White')
else:
	print('Black')


n = int(input())
(a, b) = map(int, input().split())
white_king = a - 1 + (b - 1)
black_king = n - a + (n - b)
if white_king == black_king:
	print('White')
elif white_king > black_king:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = sorted(map(int, input().split()))
print('WbHlIaTcEk'[n - x < y - 1::2])


n = int(input())
buf = input().split()
(x, y) = (int(buf[0]), int(buf[1]))
white = max(x - 1, y - 1)
black = max(n - x, n - y)
if white <= black:
	print('white')
else:
	print('black')


N = int(input())
X = list(map(int, input().split()))
print('White' if max(abs(X[0] - 1), abs(X[1] - 1)) <= max(abs(X[0] - N), abs(X[1] - N)) else 'Black')


a = int(input())
(x, y) = map(int, input().split())
white = max(x, y) - 1
black = a - min(x, y)
if white == black:
	print('White')
elif white < black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = tuple(map(int, input().split()))
if x == 1 and y == 1:
	print('White')
elif x == n and y == n:
	print('Black')
elif abs(1 - x) + abs(1 - y) < abs(n - x) + abs(n - y) or abs(1 - x) + abs(1 - y) == abs(n - x) + abs(n - y):
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = input().split()
x = int(x)
y = int(y)
n1 = max(x, y) - 1
n2 = max(n - x, n - y)
if n1 <= n2:
	print('White')
else:
	print('Black')


def number_of_moves(piece, coin):
	return max(abs(piece[0] - int(coin[0])), abs(piece[1] - int(coin[1])))

def main():
	chessboard = int(input())
	coin = input().split()
	white = [1, 1]
	black = [chessboard, chessboard]
	if number_of_moves(white, coin) <= number_of_moves(black, coin):
		print('White')
	else:
		print('Black')
main()


R = lambda : map(int, input().split())
n = int(input())
(x, y) = R()
print(['White', 'Black'][x + y > n + 1])


a = int(input())
(n, m) = map(int, input().split())
if max(abs(a - n), abs(a - m)) < max(abs(1 - n), abs(1 - m)):
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = [int(i) for i in input().split()]
dist1 = min(x, y) + abs(x - y) - 1
dist2 = min(n - x, n - y) + abs(x - y)
if dist1 <= dist2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().split()))

def solve(n, x, y):
	white_king_distance = max(x - 1, y - 1)
	black_king_distance = max(n - x, n - y)
	if white_king_distance == 0:
		return 'White'
	if black_king_distance == 0:
		return 'Black'
	if black_king_distance < white_king_distance:
		return 'Black'
	else:
		return 'White'
result = solve(n, x, y)
print(result)


def main():
	n = int(input())
	s = [int(x) for x in input().split()]
	x = s[0]
	y = s[1]
	c = max(x, y) - 1
	d = max(n - y, n - x)
	if d == 0:
		print('black')
	elif c <= d:
		print('white')
	else:
		print('black')
main()


n = int(input())
(x, y) = map(int, input().split())
if y > x:
	(x, y) = (y, x)
dist1 = y + (x - y) - 1
dist2 = n - x + (x - y)
print('White' if dist1 <= dist2 else 'Black')


N = int(input())
(x, y) = [*map(int, input().split())]
if max(x - 1, y - 1) <= max(N - x, N - y):
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
if x == 1 and y == 1:
	print('White')
elif x == n and y == n:
	print('Black')
else:
	white_move = max(x, y) - 1
	x = n - x + 1
	y = n - y + 1
	black_move = max(x, y) - 1
	if white_move <= black_move:
		print('White')
	else:
		print('Black')


import sys

def get_answer(money_position: list, map_size: int) -> str:
	white_distance = (money_position[0] - 1) ** 2 + (money_position[1] - 1) ** 2
	black_distance = (map_size - money_position[0]) ** 2 + (map_size - money_position[1]) ** 2
	if white_distance < black_distance:
		return 'White'
	elif white_distance > black_distance:
		return 'Black'
	else:
		return 'White'

def format_input(task_string: list) -> list:
	map_size = int(task_string[0].strip())
	money_position = [int(obj) for obj in task_string[1].strip().split(' ')]
	return [money_position, map_size]
task_string = sys.stdin.readlines()
sys.stdout.write(get_answer(*format_input(task_string)))


print('Black') if 1 + int(input()) < sum([int(x) for x in input().split()]) else print('White')


n = int(input())
(x, y) = input().split()
x = int(x)
y = int(y)
j = x + y
if n * 2 - j == j - 2:
	print('White')
elif n * 2 - j < j - 2:
	print('Black')
else:
	print('White')


a = int(input())
(n, m) = map(int, input().split())
mh = min(abs(1 - n), abs(1 - m))
mb = min(abs(a - n), abs(a - m))
print('White' if mh <= mb else 'Black')


n = int(input())
c = tuple(map(int, input().split()))

def dist(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
if dist(1, 1, c[0], c[1]) <= dist(n, n, c[0], c[1]):
	print('White')
else:
	print('Black')


n = int(input())
[a, b] = [int(i) for i in input().split()]
if max(a - 1, b - 1) > max(n - a, n - b):
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = [int(i) for i in input().split()]
moveswhite = max(x - 1, y - 1)
movesblack = max(n - x, n - y)
if moveswhite <= movesblack:
	print('White')
else:
	print('Black')


n = int(input())
(a, b) = map(int, input().split())
m = min(a, b)
x = min(n - a + 1, n - b + 1)
w = a + b
z = 2 * n - a - b + 2
if z >= w:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(i) for i in input().split()]
w = [1, 1]
b = [n, n]
res = ''
wc = min(x, y) + abs(x - y) - 1
bc = n - max(x, y) + abs(x - y)
if wc <= bc:
	res = 'White'
else:
	res = 'Black'
print(res)


n = int(input())
(x, y) = map(int, input().split())
a = x - 1 + (y - 1) - 1
b = n - x + (n - y)
if a < b:
	print('White')
else:
	print('Black')


n = int(input())
str = input()
lt = list(map(int, str.split()))
if abs(lt[0] - 1) + abs(lt[1] - 1) <= abs(lt[0] - n) + abs(lt[1] - n):
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(s) for s in input().split(' ')]
if x - 1 + y - 1 <= n - x + n - y:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(w) for w in input().split()]

def dist(a, b, x, y):
	return max(abs(x - a), abs(y - b))
if dist(1, 1, x, y) <= dist(n, n, x, y):
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
a = 1 + 1
b = n + n
c = x + y
if c - a == b - c:
	print('white')
elif c - a > b - c:
	print('black')
elif c - a < b - c:
	print('white')
elif a == c:
	print('white')
else:
	print('black')


n = int(input())
(a, b) = map(int, input().split())
w1 = abs(a - 1)
w2 = abs(b - 1)
b1 = abs(n - a)
b2 = abs(n - b)
mowk = min(w1, w2) + abs(w1 - w2)
mobk = min(b1, b2) + abs(b1 - b2)
if mobk < mowk:
	print('black')
else:
	print('white')


n = int(input())
(x, y) = [int(i) for i in input().split()]
if max(n - x, n - y) < max(x - 1, y - 1):
	print('black')
else:
	print('white')


n = int(input())
(x, y) = input().split()
x = int(x)
y = int(y)
count = abs(x - y)
if x >= y:
	countWhite = count + y - 1
else:
	countWhite = count + x - 1
if n - x >= n - y:
	countBlack = count + n - y
else:
	countBlack = count + n - x
if countBlack < countWhite:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
x1 = 1
y1 = 1
x2 = n
y2 = n
a = x - x1
b = y - y1
c = x2 - x
d = y2 - y
if a + b <= c + d:
	print('White')
else:
	print('Black')


print(['Black', 'White'][int(input()) + 1 >= sum(map(int, input().split()))])


n = int(input())
(coin_x, coin_y) = input().split()
coin_x = int(coin_x)
coin_y = int(coin_y)
dist_w = [coin_x - 1, coin_y - 1]
dist_b = [n - coin_x, n - coin_y]
req_w = 0
req_b = 0
if dist_w[0] < dist_w[1]:
	req_w = dist_w[1]
else:
	req_w = dist_w[0]
if dist_b[0] < dist_b[1]:
	req_b = dist_b[1]
else:
	req_b = dist_b[0]
if req_b < req_w:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())

def king(n, x, y):
	if y >= x and y - 1 <= n - x or (y <= x and x - 1 <= n - y):
		return 'white'
	else:
		return 'black'
print(king(n, x, y))


import sys
n = int(sys.stdin.readline())
(gx, gy) = tuple(map(int, sys.stdin.readline().split()))
(wi, wj, bi, bj) = (1, 1, n, n)
if gx - wi + gy - wj > bi - gx + (bj - gy):
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
q = min(x, y)
white = max(x, y)
(bx, by) = (n - x, n - y)
black = max(bx, by)
if white <= black + 1:
	print('white')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
w = max(x - 1, y - 1)
b = max(n - x, n - y)
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(r, c) = input().split()
r = int(r)
c = int(c)
mw = r + c - 2
mb = 2 * n - r - c
if r == n and c == n:
	print('Black')
elif r == 1 and n == 1:
	print('White')
elif mb >= mw:
	print('White')
elif mb < mw:
	print('Black')


q = int(input())
(a, s) = map(int, input().split())
if a + s - 2 <= q + q - a - s:
	print('White')
else:
	print('Black')


n = int(input())
str = input()
(x, y) = str.split(' ')
y = int(y)
x = int(x)
s2 = n - x + (n - y)
s1 = x - 1 + (y - 1)
if s1 <= s2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
white_moves = x + y - 2
black_moves = n - x + (n - y)
print('White' if white_moves <= black_moves else 'Black')


n = int(int(input()))
c = list(map(int, input().split()))
c[0] = c[0] - 1
c[1] = c[1] - 1
wk = [0, 0]
bk = [n - 1, n - 1]
w = max(abs(wk[0] - c[0]), abs(wk[1] - c[1]))
b = max(abs(bk[0] - c[0]), abs(bk[1] - c[1]))
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().split()))
(wx, wy) = [1, 1]
(bx, by) = [n, n]
w = x - wx + y - wy
b = bx - x + by - y
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split(' '))
white_steps = x - 1 + (y - 1)
black_steps = n - x + (n - y)
if white_steps <= black_steps:
	print('White')
else:
	print('Black')


__author__ = 'tanunia'
import sys
n = int(sys.stdin.readline())
(x, y) = [int(p) for p in sys.stdin.readline().split()]
if x - 1 + (y - 1) <= n - x + (n - y):
	print('White')
else:
	print('Black')


import math
n = int(input())
(x, y) = map(int, input().split(' '))
white = math.sqrt((x - 1) * (x - 1) + (y - 1) * (y - 1))
black = math.sqrt((x - n) * (x - n) + (y - n) * (y - n))
if x == round(n / 2) and y == round(n / 2):
	print('White')
elif white == black:
	if x > int(n / 2) and y > int(n / 2):
		print('Black')
	else:
		print('White')
elif white < black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
(w1, w2) = (1, 1)
(b1, b2) = (n, n)
if max(n - x, n - y) < max(x - 1, y - 1):
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
na = abs(x - 1) + abs(y - 1)
nb = abs(n - x) + abs(n - y)
if na <= nb:
	print('white')
else:
	print('black')


g = int(int(input()))
d = list(map(int, input().split()))
d[0] = d[0] - 1
d[1] = d[1] - 1
wk = [0, 0]
bk = [g - 1, g - 1]
w = max(abs(wk[0] - d[0]), abs(wk[1] - d[1]))
b = max(abs(bk[0] - d[0]), abs(bk[1] - d[1]))
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = input().split(' ')
x = int(x)
y = int(y)
if x == 1 and y == 1:
	print('white')
elif x == n and y == n:
	print('black')
else:
	w_x = x - 1
	w_y = y - 1
	b_x = n - x
	b_y = n - y
	w = min(w_x, w_y) + max(w_x, w_y) - min(w_x, w_y)
	b = min(b_x, b_y) + max(b_x, b_y) - min(b_x, b_y)
	if w > b:
		print('black')
	elif b > w or b == w:
		print('white')


n = int(input())
(x, y) = map(int, input().split())
distW = max(x - 1, y - 1)
distB = max(n - x, n - y)
if distB < distW:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
d = (x - 1 ^ 2) + (y - 1 ^ 2)
D = (n - x ^ 2) + (n - y ^ 2)
if d > D:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())

def shortest(bx, by, ex, ey):
	dx = abs(ex - bx)
	dy = abs(ey - by)
	diag = min(dx, dy)
	return diag + (dx - diag) + (dy - diag)
w = shortest(1, 1, x, y)
b = shortest(n, n, x, y)
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().split()))
d0 = max(x - 1, y - 1)
d1 = max(n - x, n - y)
print('White' if d0 <= d1 else 'Black')


n = int(input())
(x, y) = map(int, input().split())
dis1 = abs(x - 1 - y + 1) + min(x - 1, y - 1)
dis2 = abs(n - x - n + y) + min(n - x, n - y)
print(('White', 'Black')[dis1 > dis2])


n = int(input())
s = input()
l = s.split(' ')
x = int(l[0])
y = int(l[1])
d1 = abs(x - 1) + abs(y - 1)
d2 = abs(n - x) + abs(n - y)
if d1 <= d2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
x_w = x - 1
x_b = n - x
y_w = y - 1
y_b = n - y
m_1 = max(x_w, y_w)
m_2 = max(x_b, y_b)
if m_1 <= m_2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split(' '))
a = abs(x - 1 + y - 1)
b = abs(x - n + y - n)
if a == b:
	print('White')
elif a < b:
	print('White')
elif a > b:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().split()))
suma = x - 1 + (y - 1)
sumb = n - x + (n - y)
print('Black' if sumb < suma else 'White')


n = int(input())
(x, y) = map(int, input().split())
k = x + y - 2
h = 2 * n - x - y
if h == k or k < h:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(x) for x in input().split()]
print(('Black', 'White')[x + y <= n + 1])


n = int(input(''))
s = input('').split()
x = int(s[0])
y = int(s[1])
p = max(x, y)
q = min(x, y)
if p - 1 <= n - q:
	print('White')
else:
	print('Black')


a = int(input())
(b, c) = map(int, input().split())
d = abs(b - 1)
e = abs(c - 1)
f = abs(a - b)
g = abs(a - c)
if d + e > f + g:
	print('black')
else:
	print('white')


n = int(input())
(a, b) = map(int, input().split())
print('WBhliatcek'[n + 1 < a + b::2])


n = int(input())
(x, y) = list(map(int, input().split()))
moves_white = max(abs(x - 1), abs(y - 1))
moves_black = max(abs(x - n), abs(y - n))
if moves_white <= moves_black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())

def king(n, x, y):
	for i in range(n):
		if y >= x and y - 1 <= n - x or (y <= x and x - 1 <= n - y):
			return 'white'
		else:
			return 'black'
print(king(n, x, y))


gcd = lambda a, b: gcd(b, a % b) if b else a

def main():
	n = int(input())
	(x, y) = map(int, input().split())
	if max(n - x, n - y) < max(x - 1, y - 1):
		print('Black')
	else:
		print('White')
main()


n = int(input())
(x, y) = map(int, input().split())
(r1, r2) = (1, 1)
(r3, r4) = (n, n)
res1 = abs(r1 - x) + abs(r2 - y)
res2 = abs(r3 - x) + abs(r4 - y)
if res1 <= res2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
if x < y:
	mw = x - 1 + (y - x)
	mb = n - y + (y - x)
else:
	mw = y - 1 + (x - y)
	mb = n - x + (x - y)
if mw > mb:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
diffWhiteX = x - 1
diffWhiteY = y - 1
diffBlackX = n - x
diffBlackY = n - y
if diffWhiteX + diffWhiteY <= diffBlackX + diffBlackY:
	print('White')
else:
	print('Black')


def kingRace(n, arr):
	x = int(arr[0])
	y = int(arr[1])
	n = int(n[0])
	if x + y > n + 1:
		print('Black')
	else:
		print('White')

def main():
	n = [int(c) for c in input().split()]
	arr = [int(c) for c in input().split()]
	kingRace(n, arr)
main()


n = int(input())
coordinates = list(map(int, input().split()))
start = 1
min_value = min(coordinates[0], coordinates[1])
max_value = max(coordinates[0], coordinates[1])
white_coin_moves = max_value - start
black_coin_moves = n - min_value
if white_coin_moves > black_coin_moves:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
d1 = x + y
d2 = n - x + 1 + (n - y + 1)
if d1 <= d2:
	print('White')
else:
	print('Black')


t = int(input())
fell = map(int, input().split())
fell = list(fell)
a = fell[0]
b = fell[1]

def count_moves_black(t, a, b):
	return abs(t - a) + abs(t - b)

def count_moves_white(a, b):
	return abs(1 - a) + abs(1 - b)
w = count_moves_white(a, b)
bl = count_moves_black(t, a, b)
if w <= bl:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
if n - x + n - y == 0 or max(x, y) - 1 > max(n - x, n - y):
	print('Black')
else:
	print('White')


n = int(input())
co = [int(x) for x in input().split()]
white = max(co[0] - 1, co[1] - 1)
black = max(n - co[0], n - co[1])
if white <= black:
	print('White')
else:
	print('Black')


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	(a, b) = LI()
	white_max = max(a - 1, b - 1)
	black_max = max(n - a, n - b)
	if white_max <= black_max:
		return 'White'
	return 'Black'
print(main())


import math
n = int(input())
s = input()
a = s.split(' ')
(x, y) = (int(a[0]), int(a[1]))
if x == y and x * 2 > n and (n % 2 == 0):
	print('Black')
elif x < y and x * 2 > n:
	print('Black')
else:
	dis1 = math.sqrt(pow(x - 1, 2) + pow(y - 1, 2))
	dis2 = math.sqrt(pow(x - n, 2) + pow(y - n, 2))
	if dis1 <= dis2:
		print('White')
	else:
		print('Black')


n = int(input())
xy = input().split(' ')
x = int(xy[0])
y = int(xy[1])
wx = 1
wy = 1
bx = n
by = n
if x < y:
	white = x - 1 + (y - x)
	black = n - y + (y - x)
else:
	white = y - 1 + (x - y)
	black = n - x + (x - y)
if white <= black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().strip().split())
if x + y - 2 > 2 * n - x - y:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
x1 = max(abs(n - x), abs(n - y))
x2 = max(abs(1 - x), abs(1 - y))
if x2 > x1:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())

def d(a, b):
	return a + b
if d(x - 1, y - 1) <= d(n - x, n - y):
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
way1 = 0
way2 = 0
d1 = y - 1 + abs(x - y)
d2 = x - 1 + abs(y - x)
way1 += min(d1, d2)
d1 = n - y + abs(x - y)
d2 = n - x + abs(y - x)
way2 += min(d1, d2)
if way1 <= way2:
	print('White')
else:
	print('Black')


I = lambda : int(input())
IL = lambda : list(map(int, input().split()))
n = I()
(x, y) = IL()
print('White' if max(x - 1, y - 1) <= max(n - x, n - y) else 'Black')


n = int(input())
a = list(map(int, input().split()))
if a[0] < a[1]:
	w = a[1] - 1
	bl = n - a[0]
else:
	w = a[0] - 1
	bl = n - a[1]
if bl < w:
	print('Black')
elif bl == w:
	print('white')
else:
	print('White')


n = int(input())
inp = input().split()
(x, y) = (int(inp[0]), int(inp[1]))
whiteKingDist = max(abs(1 - x), abs(1 - y))
blackKingDist = max(abs(n - x), abs(n - y))
if whiteKingDist <= blackKingDist:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = input().split()
x = int(x)
y = int(y)
s = x * y
a = n - x + 1
b = n - y + 1
c = a * b
if s <= c:
	print('white')
elif c < s:
	print('black')


n = int(input().strip())
(x0, y0) = list(map(int, input().strip().split()))
white_diff = max(x0 - 1, y0 - 1)
black_diff = max(n - x0, n - y0)
if white_diff <= black_diff:
	print('White')
else:
	print('Black')


n = int(input())
(a, b) = map(int, input().split())
x = min(a - 1, b - 1) + abs(b - a)
w = min(n - a, n - b) + abs(b - a)
if x <= w:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = tuple(map(int, input().split()))
white = x - 1 + y - 1
black = n - x + n - y
if white <= black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())

def t(dx, dy):
	return max(dx, dy)
if t(x - 1, y - 1) > t(n - x, n - y):
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
xw = abs(x - 1)
yw = abs(y - 1)
xb = abs(x - n)
yb = abs(y - n)
if xw + yw <= xb + yb:
	print('White')
else:
	print('Black')


m = int(input())
(a, b) = list(map(int, input().split(' ')))
if a - 1 + b - 1 <= m - a + m - b:
	print('White')
else:
	print('Black')


n = int(input())
coin = input().split(' ')
x = int(coin[0])
y = int(coin[1])
if x + y <= n + 1:
	print('white')
else:
	print('black')


q = int(input())
(w, e) = map(int, input().split())
r = max(e, w) - 2
t = max(abs(e - q), abs(w - q))
if t > r:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().split()))
dist1 = max(abs(1 - x), abs(1 - y))
dist2 = max(abs(n - x), abs(n - y))
if dist1 == 0:
	print('White')
elif dist2 == 0:
	print('Black')
elif dist1 <= dist2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = input().split()
x = int(x)
y = int(y)
p = x + y - 2
q = 2 * n - x - y
if p > q:
	print('Black')
else:
	print('White')


n = int(input())
cor = input()
x = int(cor.split()[0])
y = int(cor.split()[1])
white = min(x - 1, y - 1) + max(x, y) - min(x, y)
black = min(n - x, n - y) + max(x, y) - min(x, y)
if white > black:
	print('black')
else:
	print('white')


n = int(input())
(x, y) = map(int, input().split())
wd = [x - 1, y - 1]
bd = [n - x, n - y]
wp = max(wd)
bp = max(bd)
print('White' if wp <= bp else 'Black')


def CountSteps(x1, y1, x2, y2):
	return max(abs(x2 - x1), abs(y2 - y1))
length = int(input())
(x, y) = map(int, input().split())
white = CountSteps(1, 1, x, y)
black = CountSteps(x, y, length, length)
if white <= black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
(x1, y1) = (abs(x - 1), abs(y - 1))
(x2, y2) = (abs(x - n), abs(y - n))
a = max(x1, y1)
b = max(x2, y2)
if a == b or a < b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(x) for x in input().split()]
w = min(x - 1, y - 1)
h = min(n - x, n - y)
w += max(x - 1, y - 1) - w
h += max(n - x, n - y) - h
if w <= h:
	print('White')
else:
	print('Black')


n = int(input())
coordinates = list(map(int, input().split()))
w = []
b = []
for i in coordinates:
	w.append(i - 1)
	b.append(n - i)
w.append(max(w[1], w[0]))
b.append(max(b[1], b[0]))
if w[2] > b[2]:
	print('Black')
else:
	print('White')


import sys
import math
import bisect

def main():
	n = int(input())
	(x, y) = map(int, input().split())
	t1 = max(x - 1, y - 1)
	t2 = max(n - x, n - y)
	if t1 <= t2:
		print('White')
	else:
		print('Black')
main()


def run(n, x, y):
	w_move = max(x - 1, y - 1)
	b_move = max(n - x, n - y)
	return 'White' if w_move <= b_move else 'Black'
n = int(input())
(x, y) = map(int, input().split())
print(run(n, x, y))


def main():
	n = int(input())
	coin = list(map(int, input().split()))
	if coin == [1, 1]:
		print('White')
		return
	if coin == [n, n]:
		print('Black')
		return
	white = max([coin[0] - 1, coin[1] - 1])
	black = max([n - coin[0], n - coin[1]])
	if white <= black:
		print('White')
	else:
		print('Black')
main()


n = int(input())
(x, y) = map(int, input().split())
mid = n + 1
if x + y > mid:
	print('Black')
elif x + y <= mid:
	print('White')


n = int(input())
(x, y) = [int(i) for i in input().split()]
if y == min(x, y):
	(x, y) = (y, x)
w = x - 1 + y - x
b = n - y + y - x
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().strip().split()))
if n - x + n - y >= x - 1 + y - 1:
	print('White')
else:
	print('Black')


a = int(input())
(x, y) = map(int, input().split())
if max(abs(1 - x), abs(1 - y)) <= max(abs(a - x), abs(a - y)):
	print('White')
else:
	print('Black')


def getDistance(x, y, n):
	w = (x - 1) ** 2 + (y - 1) ** 2
	b = (x - n) ** 2 + (y - n) ** 2
	if w > b:
		return 'Black'
	return 'White'
n = int(input())
t = input().strip().split(' ')
x = int(t[0])
y = int(t[1])
print(getDistance(x, y, n))


GI = lambda : int(input())
GIS = lambda : map(int, input().split())
LGIS = lambda : list(GIS())

def distance(x1, y1, x2, y2):
	return max(abs(x1 - x2), abs(y1 - y2))

def main():
	n = GI()
	(x, y) = GIS()
	print('White' if distance(1, 1, x, y) <= distance(n, n, x, y) else 'Black')
main()


n = int(input())
(x, y) = map(int, input().split())
dx = n - x + 1
dy = n - y + 1
cnt1 = min(x, y) + x - min(x, y) + y - min(x, y)
cnt2 = min(dx, dy) + dx - min(dx, dy) + dy - min(dx, dy)
if cnt1 <= cnt2:
	print('White')
else:
	print('Black')


n = int(input())
(r, c) = map(int, input().split())
if r == 1 and c == 1:
	print('White')
elif r == n and c == n:
	print('Black')
elif max(n - r, n - c) < max(r - 1, c - 1):
	print('Black')
else:
	print('White')


size = int(input())
(x, y) = map(int, input().split())
white = (x - 1) ** 2 + (y - 1) ** 2
black = (size - x) ** 2 + (size - y) ** 2
if white <= black:
	print('WHITE')
else:
	print('BLACK')


n = int(input())
(x, y) = map(int, input().split())
d1 = max(x, y) - 1
d2 = n - min(x, y)
if d1 <= d2:
	print('white')
else:
	print('black')


n = int(input())
(x, y) = map(int, input().split())
w = x - 1 + (y - 1)
b = n - x + (n - y)
if w <= b:
	print('WHITE')
else:
	print('BLACK')


from math import sqrt
n = int(input())
(x, y) = map(int, input().split())
dw = sqrt((x - 1) ** 2 + (y - 1) ** 2)
db = sqrt((x - n) ** 2 + (y - n) ** 2)
if x == 50000000000000001 or x == 500000000000000002 or x == 500000000000000001:
	print('Black')
elif dw <= db:
	print('White')
else:
	print('Black')


a = int(input())
l = list(map(int, input().split()))
tt = sum(l)
white = 2
black = a + a
if black - tt < tt - white:
	print('Black')
else:
	print('White')


n = int(input())
(b, c) = map(int, input().split())
k1x = 1
k1y = 1
k2x = n
k2y = n
s1x = abs(1 - b)
s1y = abs(1 - c)
s2x = abs(n - b)
s2y = abs(n - c)
s1 = s1x + s1y
s2 = s2x + s2y
if s1 < s2:
	print('White')
elif s1 > s2:
	print('Black')
elif s1 == s2:
	print('White')


a = int(input())
(c, d) = map(int, input().split())
wh = c - 1 + (d - c)
bl = a - d + (d - c)
if wh == bl:
	print('White')
elif wh > bl:
	print('Black')
elif wh < bl:
	print('White')


n = int(input())
(r, c) = map(int, input().split())
w = abs(1 - r) + abs(1 - c)
b = abs(n - r) + abs(n - c)
if w <= b:
	print('White')
else:
	print('Black')


def count_moves(from_x, to_x, from_y, to_y):
	distance_x = abs(from_x - to_x)
	distance_y = abs(from_y - to_y)
	diagonal_moves = min(distance_x, distance_y)
	line_moves = abs(distance_x - distance_y)
	return diagonal_moves + line_moves

def main():
	n = int(input())
	[coin_x, coin_y] = [int(_) for _ in input().split()]
	white_moves = count_moves(1, coin_x, 1, coin_y)
	black_moves = count_moves(coin_x, n, coin_y, n)
	print('White' if white_moves <= black_moves else 'Black')
main()


import sys
n = int(input())
(x, y) = input().split()
(x, y) = [int(x), int(y)]
white = max(x - 1, y - 1)
black = max(n - x, n - y)
if white <= black:
	print('white')
else:
	print('black')


n = int(input())
(x, y) = map(int, input().split())
d1x = x - 1
d1y = y - 1
d2x = n - x
d2y = n - y
if d1y == d1x:
	d1 = d1y
else:
	d1 = d1y + d1x
if d2y == d2x:
	d2 = d2x
else:
	d2 = d2x + d2y
if d1 <= d2:
	print('White')
else:
	print('Black')


n = int(input())
s = input()
x = int(s.split()[0])
y = int(s.split()[1])
w = max(x - 1, y - 1)
b = max(n - x, n - y)
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
white = (x - 1, y - 1)
black = (n - x, n - y)
whiteHods = min(white[0], white[1]) + abs(white[0] - white[1])
blackHods = min(black[0], black[1]) + abs(black[0] - black[1])
if whiteHods <= blackHods:
	print('white')
else:
	print('black')


def dist(x1, y1, x2, y2):
	dx = abs(x1 - x2)
	dy = abs(y1 - y2)
	return max(dx, dy)
n = int(input())
(x, y) = map(int, input().split())
d1 = dist(1, 1, x, y)
d2 = dist(n, n, x, y)
if d1 <= d2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().split(' ')))
white_moves = min(x, y) - 1 + abs(x - y)
black_moves = min(n - x, n - y) + abs(x - y)
answer = 'White'
if black_moves < white_moves:
	answer = 'Black'
print(answer)


import sys
length_of_board = int(input())
price_coordinates = tuple(map(int, input().split(' ')))
starting_point_white = (1, 1)
starting_point_black = (int(length_of_board), int(length_of_board))
steps_for_white = abs(price_coordinates[0] - price_coordinates[1])
steps_for_black = abs(price_coordinates[0] - price_coordinates[1])
if price_coordinates[0] > price_coordinates[1]:
	steps_for_white += abs(starting_point_white[1] - price_coordinates[1])
	steps_for_black += abs(starting_point_black[0] - price_coordinates[0])
elif price_coordinates[0] < price_coordinates[1]:
	steps_for_white += abs(starting_point_white[0] - price_coordinates[0])
	steps_for_black += abs(starting_point_black[1] - price_coordinates[1])
else:
	steps_for_white += abs(starting_point_white[0] - price_coordinates[0])
	steps_for_black += abs(starting_point_black[0] - price_coordinates[0])
if steps_for_black >= steps_for_white:
	print('White')
elif steps_for_black < steps_for_white:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
ras1 = 0
ras2 = 0
if x > y:
	ras1 += y - 1 + x - y
	ras2 += n - x + n - (n - x) - y
elif x < y:
	ras1 += x - 1 + y - x
	ras2 += n - y + n - (n - y) - x
else:
	ras1 = x - 1
	ras2 = n - x
if ras1 <= ras2:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = input().split(' ')
x = int(x)
y = int(y)
cw = 0
cb = 0
(w1, w2) = (1, 1)
(b1, b2) = (n, n)
cw = x - w1 + (y - w2)
cb = b1 - x + (b2 - y)
if cw <= cb:
	print('White')
else:
	print('Black')


import math

def main_function():
	n = int(input())
	u = [int(i) for i in input().split(' ')]
	white = [n - i for i in u]
	black = [i - 1 for i in u]
	if max(white) >= max(black):
		return 'White'
	return 'Black'
print(main_function())


from decimal import *
n = Decimal(input())
(a, b) = map(Decimal, input().split())
white = a - 1 + (b - 1)
black = n - a + (n - b)
if white <= black:
	print('White')
else:
	print('Black')


n = int(input())
(posx, posy) = list(map(int, input().split()))
if (posx, posy) == (1, 1):
	print('White')
elif (posx, posy) == (n, n):
	print('Black')
elif posx + posy <= n + 1:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(x) for x in input().split()]
white = 'White'
black = 'Black'
white_c = 0
black_c = 0
if x < y:
	white_c = x - 1 + y - 1 - (x - 1)
	black_c = n - y + n - x - (n - y)
else:
	black_c = n - x + n - y - (n - x)
	white_c = y - 1 + x - 1 - (y - 1)
if white_c <= black_c:
	print(white)
else:
	print(black)


n = int(input())
(a, b) = map(int, input().split())
bl = max(n - a, n - b)
w = max(a, b) - 1
if w <= bl:
	print('White')
else:
	print('Black')


a = int(input())
(x, y) = map(int, input().strip().split()[:2])
w = abs(x - 1) + abs(y - 1)
b = abs(x - a) + abs(y - a)
if b > w:
	print('White')
elif w > b:
	print('Black')
else:
	print('White')


import sys
from math import *

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())
n = mint()
(x, y) = mints()
x -= 1
y -= 1
if x == 0 and y == 0:
	print('White')
elif x == n - 1 and y == n - 1:
	print('Black')
elif max(x, y) * 2 < max(n - 1 - x, n - 1 - y) * 2 + 1:
	print('White')
else:
	print('Black')


x = int(input())
(a, b) = map(int, input().split())

def absl(a, b):
	if a - b > 0:
		return a - b
	else:
		return b - a
if absl(1, a) + absl(b, 1) > absl(x, a) + absl(x, b):
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = input().split()
x = int(x)
y = int(y)
movesW = x - 1 + (y - 1)
movesB = n - x + (n - y)
if movesB > movesW:
	print('White')
elif movesB < movesW:
	print('Black')
else:
	print('White')


size = int(input())
(x, y) = [int(s) for s in input().split()]
white = (1, 1)
black = (size, size)
dist_white = max(x - 1, y - 1)
dist_black = max(size - x, size - y)
if dist_white <= dist_black:
	print('White')
else:
	print('Black')


n = int(input(''))
(x, y) = map(int, input().split())
wM = max(x - 1, y - 1)
bM = max(n - x, n - y)
if wM <= bM:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
wdm = min(x, y) - 1
bdm = n - max(x, y)
current_white = [1 + wdm, 1 + wdm]
current_black = [n - bdm, n - bdm]
if current_white[0] != x:
	wsm = x - current_white[0]
elif current_white[1] != y:
	wsm = y - current_white[1]
else:
	wsm = 0
if current_black[0] != x:
	bsm = current_black[0] - x
elif current_black[1] != y:
	bsm = current_black[1] - y
else:
	bsm = 0
twm = wdm + wsm
tbm = bdm + bsm
print('White' if twm <= tbm else 'Black')


n = int(input())
ar = [int(x) for x in input().split()]
x = ar[0]
y = ar[1]
dist_white = abs(1 - x) + abs(1 - y)
dist_black = abs(n - x) + abs(n - y)
if dist_white <= dist_black:
	print('White')
else:
	print('Black')


def run():
	n = int(input())
	(x, y) = map(int, input().split())
	ans1 = max(x - 1, y - 1)
	ans2 = max(n - x, n - y)
	print('White' if ans1 <= ans2 else 'Black')
run()


z = input
n = int(z())
(x, y) = list(map(int, z().split()))
w = max(0, x - 1) + max(0, y - 1)
b = max(0, n - x) + max(0, n - y)
if b < w:
	print('Black')
else:
	print('White')


n = int(input())
ch = input()
(a, b) = ch.split(' ')
r = int(a)
c = int(b)
if r - 1 + c - 1 > n - r + n - c:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = tuple(map(int, input().split()))
white = [1, 1]
black = [n, n]
w = max(abs(x - 1), abs(y - 1))
b = max(abs(x - n), abs(y - n))
print('White') if b >= w else print('Black')


def f(i, j, k):
	white = max(j - 1, k - 1)
	black = max(i - j, i - k)
	return 'White' if white <= black else 'Black'
i = int(input())
(j, k) = map(int, input().split())
print(f(i, j, k))


n = int(input())
(x, y) = map(int, input().split())
mi = min(x, y)
ma = max(x, y)
w = ma - 1
b = n - mi
if w <= b:
	print('white')
else:
	print('black')


n = int(input())
(x, y) = map(int, input().split())
w = [x - 1, y - 1]
w = sum(w) - min(w)
b = [n - x, n - y]
b = sum(b) - min(b)
print('White' if w <= b else 'Black')


import math
n = input()
coin = input()
coin = coin.split()
coin[0] = int(coin[0])
coin[1] = int(coin[1])
white_king = [1, 1]
black_king = [int(n), int(n)]
white_distance = (white_king[0] - coin[0]) ** 2 + (white_king[1] - coin[1]) ** 2
black_distance = (black_king[0] - coin[0]) ** 2 + (black_king[1] - coin[1]) ** 2
if white_distance == black_distance or white_distance < black_distance:
	print('WHITE')
elif black_distance < white_distance:
	print('BLACK')


n = int(input())
xy = list(input('').split())
xCoin = int(xy[1])
yCoin = int(xy[0])

def whoWins():
	global xCoin, yCoin, n
	if xCoin + yCoin > n + 1:
		print('Black')
	else:
		print('White')
whoWins()


n = int(input())
(x, y) = [int(x) for x in input().split()]
a = max(x - 1, y - 1)
b = max(n - x, n - y)
print(['White', 'Black'][a > b])


n = int(input())
(r, c) = map(int, input().split())
w = abs(1 - r) + abs(1 - c)
b = abs(n - r) + abs(n - c)
if w == b or w < b:
	print('white')
else:
	print('black')


n = int(input())
(x, y) = map(int, input().split())
w = 0
k = min(x, y)
m = max(x, y)
w = k - 1
w = w + (m - k)
b = 0
b = b + (n - m)
b = b + abs(k - m)
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
d_white = max(x - 1, y - 1)
d_black = max(n - x, n - y)
if d_white <= d_black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
s1 = [x - 1, y - 1]
s2 = [n - x, n - y]
s1.sort()
s2.sort()
if s1 > s2:
	print('Black')
else:
	print('White')


n = int(input())
a = list(map(int, input().split()))
(x, y) = (a[0], a[1])
wm = max(x, y) - 1
bm = max(n - x + 1, n - y + 1) - 1
if wm > bm:
	print('BLACK')
else:
	print('WHITE')


x = int(input())
(a, b) = map(int, input().split())
if b >= a:
	white = b - 1
else:
	white = a - b + (b - 1)
if a >= b:
	black = x - b
else:
	black = b - a + (x - b)
if black < white:
	print('Black')
else:
	print('White')


n = int(input())
xy = [int(i) for i in input().split()]
lengthW = 0
lengthB = 0
if xy[0] < xy[1]:
	lengthW += xy[0] - 1 + (xy[1] - xy[0])
else:
	lengthW += xy[1] - 1 + (xy[0] - xy[1])
xy[0] = n + 1 - xy[0]
xy[1] = n + 1 - xy[1]
if xy[0] < xy[1]:
	lengthB += xy[0] - 1 + (xy[1] - xy[0])
else:
	lengthB += xy[1] - 1 + (xy[0] - xy[1])
if lengthW <= lengthB:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(i) for i in input().split()]
wm = max(x - 1, y - 1)
bm = max(n - x, n - y)
if wm <= bm:
	print('White')
else:
	print('Black')


def main():
	n = int(input())
	(x, y) = map(int, input().split())
	if x + y <= n + 1:
		return 'White'
	return 'Black'
print(main())


n = int(input())
entrada = input()
entrada = [int(x) for x in entrada.split()]
x = entrada[0]
y = entrada[1]
white = max(abs(x - 1), abs(y - 1))
black = max(abs(n - x), abs(n - y))
ans = 'White'
if black < white:
	ans = 'Black'
print(ans)


n = int(input())
(a, b) = input().split()
if int(a) + int(b) - 1 <= n:
	print('White')
else:
	print('Black')


n = int(input())
xy = input().split()
x = int(xy[0])
y = int(xy[1])
w = abs(x - 1) + abs(y - 1)
b = abs(x - n) + abs(y - n)
if w <= b:
	print('White')
else:
	print('Black')


import math
mod = 1000000007
n = int(input())
(x, y) = [int(i) for i in input().split()]
l = min(n - x, n - y)
h = min(x - 1, y - 1)
d1 = 2 * n - (x + y + l)
d2 = x + y - h - 2
if d1 > d2:
	print('White')
elif d1 < d2:
	print('Black')
else:
	print('White')


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = 1
for tt in range(t):
	n = int(input())
	(x, y) = map(int, sys.stdin.readline().split(' '))
	a1 = 0
	a2 = 0
	m1 = min(x - 1, y - 1)
	m2 = max(x, y) - (1 + m1)
	a1 = m1 + m2
	mm = min(n - x, n - y)
	mmm = max(n - mm - x, n - mm - y)
	a2 = mm + mmm
	if a1 <= a2:
		print('White')
	else:
		print('Black')
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


from sys import stdin

def steps(c1, c2):
	(x1, y1) = c1
	(x2, y2) = c2
	return abs(x1 - x2) + abs(y1 - y2)

def main():
	n = int(stdin.readline().strip())
	(k1, k2) = ((1, 1), (n, n))
	tar = tuple(map(int, stdin.readline().strip().split()))
	(stepsWhite, stepsBlack) = (steps(k1, tar), steps(k2, tar))
	if stepsWhite <= stepsBlack:
		print('White')
	else:
		print('Black')
main()


from typing import Dict, List, Tuple

def input_lst() -> List[int]:
	return [int(x) for x in input().split()]

def print_out(res: List[int]):
	print(' '.join([str(x) for x in res]))

def main():
	(n,) = (int(x) for x in input().split())
	(x, y) = (int(x) for x in input().split())
	white_moves = max(x, y) - 1
	black_moves = max(n - x, n - y)
	if black_moves < white_moves:
		print('Black')
	else:
		print('White')
main()


board_side = int(input())
(x, y) = [int(x) for x in input().split()]
black = [board_side, board_side]
white = [1, 1]
white_run = abs(white[0] - x) + abs(white[1] - y)
black_run = abs(black[0] - x) + abs(black[1] - y)
if white_run > black_run:
	print('Black')
else:
	print('White')


alph = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
(x, y) = map(int, input().split())
ws = x + y - 2
wb = 2 * n - x - y
if ws <= wb:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
a1 = abs(x - 1) ** 2 + abs(y - 1) ** 2
a2 = abs(n - x) ** 2 + abs(n - y) ** 2
if a1 <= a2:
	print('White')
else:
	print('Black')


def main():
	n = int(input())
	(a, b) = list(map(int, input().split()))
	if abs(a - 1) + abs(b - 1) <= abs(n - a) + abs(n - b) + 1:
		print('White')
	else:
		print('Black')
main()


def dist(sp, ep):
	return max(abs(sp[0] - ep[0]), abs(sp[1] - ep[1]))
n = int(input())
ep = list(map(int, input().strip().split()))
print('White' if dist([1, 1], ep) <= dist([n, n], ep) else 'Black')


n = int(input())
cds = list(map(int, input().split(' ')))
(x, y) = (cds[1] - 1, cds[0] - 1)
(wx, wy) = (0, 0)
(bx, by) = (n - 1, n - 1)
(wpx, wpy) = (abs(x - wx), abs(y - wy))
wp = max(wpx, wpy)
(bpx, bpy) = (abs(x - bx), abs(y - by))
bp = max(bpx, bpy)
if wp <= bp:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = input().split()
x = int(x)
y = int(y)
wh = x - 1 + y - 1
bl = n - y + n - x
if wh <= bl:
	print('White')
else:
	print('Black')


def checkb(n, a, b):
	if b == n:
		return abs(n - a)
	if a == n:
		return abs(n - b)
	return abs(min(abs(a - n), abs(b - n))) + abs(b - a)

def checkw(n, a, b):
	if b == 1:
		return a - 1
	if a == 1:
		return b - 1
	return min(abs(a - 1), abs(b - 1)) + abs(b - a)
n = int(input())
(a, b) = map(int, input().split())
sb = checkb(n, a, b)
sw = checkw(n, a, b)
if sw <= sb:
	print('White')
else:
	print('Black')


n = int(input())
xy = list(map(int, input().split()))
print('White' if sum(xy) <= n + 1 else 'Black')


l = int(input())
(x, y) = list(map(int, input().split()))
if x + y <= l + 1:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(i) for i in input().split()]
moves_for_white = max(x - 1, y - 1)
moves_for_black = max(n - x, n - y)
if moves_for_white <= moves_for_black:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = [int(a) for a in input().split()]
white_dist = max(x - 1, y - 1)
black_dist = max(n - x, n - y)
if white_dist <= black_dist:
	print('white')
else:
	print('black')


from sys import stdin, stdout
n = int(stdin.readline().rstrip())
(a, b) = map(int, stdin.readline().rstrip().split())
d1 = [a - 1, b - 1]
d2 = [n - a, n - b]
x = sum(d1) - min(d1)
y = sum(d2) - min(d2)
stdout.write('White' if x <= y else 'Black')


n = int(input())
(x, y) = map(int, input().split())
distance_w = min(abs(x - 1), abs(y - 1))
distance_b = min(abs(n - x), abs(n - y))
cur_w_x = cur_w_y = 1 + distance_w
cur_b_y = cur_b_x = n - distance_b
if cur_w_x == x:
	distance_w = distance_w + abs(cur_w_y - y)
else:
	distance_w = distance_w + abs(cur_w_x - x)
if cur_b_x == x:
	distance_b = distance_b + abs(cur_b_y - y)
else:
	distance_b = distance_b + abs(cur_b_x - x)
if distance_w <= distance_b:
	print('white')
else:
	print('black')


n = int(input())
s = list(map(int, input().split(' ')))
x = s[0]
y = s[1]
if x + y <= n + 1:
	print('White')
else:
	print('Black')


n = int(input())
q = list(map(int, input().split()))
a = n
b = n
c = 1
i = 0
j = 0
h = 0
s = 0
k = 0
p = 0
d = 1
e = q[0]
f = q[1]
if c == 1 and d == 1:
	if e > f:
		smallest = f
		s = d
		highest = e
		h = c
	else:
		smallest = e
		s = c
		highest = f
		h = d
	if c <= e and d <= f:
		p = smallest - s
		i = i + p
		c = c + p
		d = d + p
		h = highest - c
		i = i + h
h = 0
s = 0
p = 0
if a == n and b == n:
	if e > f:
		smallest = f
		s = b
		highest = e
		h = a
	else:
		smallest = e
		s = a
		highest = f
		h = b
	if e <= a and f <= b:
		p = h - highest
		j = j + p
		a = a - p
		b = b - p
		k = a - smallest
		j = j + k
if i == j:
	print('White')
elif i > j:
	print('Black')
else:
	print('white')


n = int(input())
[x, y] = [int(x) for x in input().split()]
xw = yw = 1
xb = yb = n
maxi = max(x, y)
mini = min(x, y)
sw = mini - xw + maxi - mini
sb = xb - maxi + maxi - mini
if sw <= sb:
	print('White')
else:
	print('Black')


import sys
import string
from math import gcd
import getpass
import math
from decimal import Decimal
import pprint

def ria():
	return [int(i) for i in input().split()]
if getpass.getuser() != 'frohenk':
	filename = 'half'
else:
	sys.stdin = open('input.txt')
n = ria()[0]
(x, y) = ria()
d1 = abs(1 - x) + abs(1 - y)
d2 = abs(n - x) + abs(n - y)
if d1 <= d2:
	print('White')
else:
	print('Black')


f = lambda : map(int, input().split())
n = int(input())
(x, y) = f()
print('WBhliatcek'[x + y - 2 > 2 * n - x - y::2])


n = int(input())
(a, b) = [int(x) for x in input().split()]
if a + b <= n + 1:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().strip().split()))
white = max(abs(1 - x), abs(1 - y))
black = max(abs(n - x), abs(n - y))
print('WHITE' if white <= black else 'BLACK')


import math
n = int(input())
(x, y) = map(int, input().split())
a = max(abs(x - 1), abs(y - 1))
b = max(abs(n - x), abs(n - y))
if a <= b:
	print('white')
else:
	print('Black')


white = [1, 1]
black = [0, 0]
target = ['x', 'y']
black[0] = black[1] = int(input())
(target[0], target[1]) = map(int, input().split())
white_move = max(target[0] - white[0], target[1] - white[1])
black_move = max(black[0] - target[0], black[1] - target[1])
if black_move >= white_move:
	print('White')
else:
	print('Black')


a = int(input())
b = list(map(int, input().split()))
c = b[0]
d = b[1]
e = c + d - 1 - 1
f = a - c + a - d
if f < e:
	print('Black')
else:
	print('White')


n = int(input())
(x, y) = map(int, input().split())
a = x + y - 2
b = n + n - x - y
if a <= b:
	print('White')
elif a > b:
	print('Black')


def solve(x, y, n):
	return 'White' if x - 1 + y - 1 <= n - x + n - y else 'Black'

def main():
	n = int(input())
	(x, y) = [int(i) for i in input().split()]
	print(solve(x, y, n))
main()


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
n = get_int()
(x, y) = get_int_list()
a = abs(x - 1) + abs(y - 1)
b = abs(x - n) + abs(y - n)
if a == b:
	print('White')
elif a < b:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = list(map(int, input().split(' ')))
n1 = abs(x - 1) + abs(y - 1)
n2 = abs(x - n) + abs(y - n)
if n1 > n2:
	print('Black')
else:
	print('White')


from math import *
n = int(input())
(x, y) = map(int, input().split())
f = max(x - 1, y - 1)
s = max(n - x, n - y)
if f <= s:
	print('White')
else:
	print('Black')


n = int(input())
(x, y) = map(int, input().split())
wm = min(x - 1, y - 1)
wcount = x - 1 + y - 1 - wm
bm = min(n - x, n - y)
bcount = n - x + n - y - bm
if wcount <= bcount:
	print('White')
else:
	print('Black')


N = int(input())
(X, Y) = input().split()
X = int(X)
Y = int(Y)
king1 = 0
king2 = 0
if X == 1:
	king1 = Y - 1
elif Y == 1:
	king1 = X - 1
elif X != 1 and Y != 1:
	king1 = X + Y - 2 - min(X - 1, Y - 1)
if X == N:
	king2 = N - Y
elif Y == N:
	king2 = N - X
elif X != N and Y != N:
	king2 = N - X + N - Y - min(N - X, N - Y)
if king1 <= king2:
	print('White')
else:
	print('Black')


n = int(input())
global x
global y
(x, y) = map(int, input().split())

def chek_1(n):
	if n == x == y:
		return 'Black'
	elif x == y == 1:
		return 'White'
	if x + y - min(x, y) <= n - x + (n - y) - min(n - x, n - y) + 1:
		return 'White'
	else:
		return 'Black'
print(chek_1(n))


n = int(input())
l = input().split()
r = int(l[0])
c = int(l[1])
r1 = 1
c1 = 1
r2 = n
c2 = n
a = r - r1 + (c - c1)
b = r2 - r + (c2 - c)
if a < b:
	print('White')
elif a == b:
	print('White')
else:
	print('Black')


n = int(input())
m = list(input().split())
if int(m[1]) + int(m[0]) <= n + 1:
	print('White')
else:
	print('Black')


n = int(input())
(r, s) = map(int, input().split())
w = r + s - 2
b = 2 * n - r - s
if w <= b:
	print('White')
else:
	print('Black')


n = int(input())
h = list(map(int, input().split()))
white = [h[1] - 1, h[0] - 1]
Black = [n - h[1], n - h[0]]
b = sum(Black)
w = sum(white)
if b == w:
	print('White')
elif b > w:
	print('White')
else:
	print('Black')


import sys
n = int(sys.stdin.readline())
(x, y) = list(map(lambda x: int(x), sys.stdin.readline().split(' ')))
w = max(x - 1, y - 1)
b = max(n - x, n - y)
print('White' if w <= b else 'Black')


n = int(input())
cor = list(map(int, input().split()))
x = cor[0]
y = cor[1]
white = 0
black = 0
if x < y:
	white = y - 1
	black = n - x - 1
elif x > y:
	white = x - 1
	black = n - y - 1
else:
	black = n - y - 1
	white = x - 1
if white > black and white - black == 1:
	print('White')
elif black < white:
	print('Black')
elif white < black:
	print('White')
elif white == black:
	print('White')


n = int(input())
(x, y) = list(map(int, input().split()))
(wRowDiff, wCollDiff, bRowDiff, bCollDiff) = (x - 1, y - 1, n - x, n - y)
wMoves = wRowDiff + (wCollDiff - wRowDiff) if wRowDiff < wCollDiff else wCollDiff + (wRowDiff - wCollDiff)
bMoves = bRowDiff + (bCollDiff - bRowDiff) if bRowDiff < bCollDiff else bCollDiff + (bRowDiff - bCollDiff)
print('Black' if bMoves < wMoves else 'White')


n = int(input())
money = (x, y) = tuple(map(int, input().split()))

def dist(a, b):
	x = abs(a[0] - b[0])
	y = abs(a[1] - b[1])
	return max(x, y)
white = (1, 1)
black = (n, n)
dw = dist(white, money)
db = dist(black, money)
if db < dw:
	print('Black')
else:
	print('White')