Vasya decided to learn to play chess. Classic chess doesn't seem interesting to him, so he plays his own sort of chess.

The queen is the piece that captures all squares on its vertical, horizontal and diagonal lines. If the cell is located on the same vertical, horizontal or diagonal line with queen, and the cell contains a piece of the enemy color, the queen is able to move to this square. After that the enemy's piece is removed from the board. The queen cannot move to a cell containing an enemy piece if there is some other piece between it and the queen. 

There is an n × n chessboard. We'll denote a cell on the intersection of the r-th row and c-th column as (r, c). The square (1, 1) contains the white queen and the square (1, n) contains the black queen. All other squares contain green pawns that don't belong to anyone.

The players move in turns. The player that moves first plays for the white queen, his opponent plays for the black queen.

On each move the player has to capture some piece with his queen (that is, move to a square that contains either a green pawn or the enemy queen). The player loses if either he cannot capture any piece during his move or the opponent took his queen during the previous move. 

Help Vasya determine who wins if both players play with an optimal strategy on the board n × n.


-----Input-----

The input contains a single number n (2 ≤ n ≤ 10^9) — the size of the board.


-----Output-----

On the first line print the answer to problem — string "white" or string "black", depending on who wins if the both players play optimally. 

If the answer is "white", then you should also print two integers r and c representing the cell (r, c), where the first player should make his first move to win. If there are multiple such cells, print the one with the minimum r. If there are still multiple squares, print the one with the minimum c.


-----Examples-----
Input
2

Output
white
1 2

Input
3

Output
black



-----Note-----

In the first sample test the white queen can capture the black queen at the first move, so the white player wins.

In the second test from the statement if the white queen captures the green pawn located on the central vertical line, then it will be captured by the black queen during the next move. So the only move for the white player is to capture the green pawn located at (2, 1). 

Similarly, the black queen doesn't have any other options but to capture the green pawn located at (2, 3), otherwise if it goes to the middle vertical line, it will be captured by the white queen.

During the next move the same thing happens — neither the white, nor the black queen has other options rather than to capture green pawns situated above them. Thus, the white queen ends up on square (3, 1), and the black queen ends up on square (3, 3). 

In this situation the white queen has to capture any of the green pawns located on the middle vertical line, after that it will be captured by the black queen. Thus, the player who plays for the black queen wins.

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Game theory

Mathematics

Constructive algorithms


Solutions:
n = int(input())
if n % 2 == 0:
	print('white\n1 2')
else:
	print('black')


if int(input()) % 2 == 0:
	print('white')
	print('1 2')
else:
	print('black')


n = int(input())
if n == 2:
	print('white')
	print(1, 2)
elif n % 2 != 0:
	print('black')
else:
	print('white')
	print(1, 2)


n = int(input())
if n % 2:
	print('black')
else:
	print('white')
	print('1 2')


print('black' if int(input().split()[0]) % 2 else 'white\n1 2')


__author__ = 'PrimuS'
n = int(input())
if n % 2 == 1:
	print('black')
else:
	print('white')
	print('1 2')


import os
from sys import stdin, stdout

def solve(tc):
	n = int(stdin.readline().strip())
	if n % 2:
		print('black')
	else:
		print('white')
		print('1 2')
tcs = 1
tc = 1
while tc <= tcs:
	solve(tc)
	tc += 1


def main():
	n = int(input()) & 1
	print(('white', 'black')[n])
	if not n:
		print(1, 2)
main()


userInput = int(input())
if userInput % 2 != 0:
	print('black')
elif userInput % 2 == 0:
	print('white')
	print('1 2')


i = int(input())
if i % 2 == 1:
	print('black')
else:
	print('white')
	print('1 2')


def main():
	(n,) = read()
	if n % 2:
		print('black')
	else:
		print('white')
		print('1 2')

def read(mode=2):
	inputs = input().strip()
	if mode == 0:
		return inputs
	if mode == 1:
		return inputs.split()
	if mode == 2:
		return list(map(int, inputs.split()))

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='')
write(main())


import sys
n = int(sys.stdin.readline().strip())
if n % 2 == 0:
	print('white')
	print('1 2')
else:
	print('black')


def main():
	import sys
	input = sys.stdin.readline
	n = int(input())
	if n & 1:
		print('black')
	else:
		print('white')
		print(1, 2)
	return 0
main()


__author__ = 'zhan'
print('black' if int(input()) & 1 else 'white\n1 2')


from sys import stdin, stdout
I = stdin.readline
P = stdout.write
n = int(I())
if n % 2 == 0:
	P('white\n')
	if n == 2:
		P('1 2')
	else:
		P('1 2')
else:
	P('black\n')


n = int(input())
if n % 2 == 0:
	print('white')
	print(str(1) + ' ' + str(2))
else:
	print('black')


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import time
start_time = time.time()
import collections as col
import math, string
from functools import reduce

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
MOD = 10 ** 9 + 7

def solve():
	N = getInt()
	if N % 2 == 0:
		print('white')
		print(1, 2)
	else:
		print('black')
	return
solve()


print('black' if int(input()) % 2 == 1 else 'white\n1 2')


from sys import stdin
input = lambda : stdin.readline().strip()
lin = lambda : list(map(int, input().split()))
iin = lambda : int(input())
main = lambda : map(int, input().split())
from math import ceil, sqrt, factorial, log
from collections import deque
from bisect import bisect_left
mod = 998244353
mod = 1000000007

def gcd(a, b):
	(a, b) = (max(a, b), min(a, b))
	while a % b != 0:
		(a, b) = (b, a % b)
	return b

def moduloinverse(a):
	return pow(a, mod - 2, mod)

def solve(we):
	n = iin()
	if n % 2 == 0:
		print('white')
		print(1, 2)
	else:
		print('black')
qwe = 1
for _ in range(qwe):
	solve(_ + 1)


from math import ceil, log, floor, sqrt
import math
k = 1

def mod_expo(n, p, m):
	result = 1
	while p != 0:
		if p % 2 == 1:
			result = result * n % m
		p //= 2
		n = n * n % m
	return result

def min_subs(n, binary):
	(a, b) = (1, 1)
	mx = 0
	prev = not int(binary[0])
	res = [0] * n
	for i in range(n):
		if int(binary[i]) == 1:
			if int(binary[i]) == prev:
				a += 1
				b = a
			res[i] = a
		else:
			if int(binary[i]) == prev:
				b += 1
				a = b
			res[i] = b
		prev = int(binary[i])
		mx = max(mx, max(a, b))
	print(mx)
	print(*res, sep=' ')

def steps(n):
	return n // 2 + 1

def find_winner(n):
	if n % 2:
		print('black')
	else:
		print('white')
		print('1 2')

def can_palindrome(r, g, b, w):
	no = 0
	mn = pow(10, 9) + 1
	mn = min(mn, r)
	mn = min(mn, g)
	mn = min(mn, b)
	if r % 2 == 1:
		no += 1
	if g % 2 == 1:
		no += 1
	if b % 2 == 1:
		no += 1
	if w % 2 == 1:
		no += 1
	if no <= 1:
		return True
	if no == 3 and mn > 0:
		return True
	return False

def max_find(n, k, z, a):
	res = 0
	s = 0
	mx = 0
	for t in range(z + 1):
		pos = k - 2 * t
		if pos < 0:
			continue
		mx = 0
		s = 0
		for i in range(pos + 1):
			if i < n - 1:
				mx = max(mx, a[i] + a[i + 1])
			s += a[i]
		res = max(res, s + mx * t)
	return res
t = 1
while t:
	t = t - 1
	n = int(input())
	find_winner(n)


def main():
	n = int(input())
	if n % 2 == 0:
		print('white')
		print(1, 2)
	else:
		print('black')
main()


x = int(input())
if x % 2 == 1:
	print('black')
else:
	print('white')
	print('1 2')


def main():
	n = int(input())
	r = 0
	c = 0
	if n % 2 == 0:
		n_2 = int(n / 2)
		if n_2 % 2 == 0:
			r = n
			c = n_2 + 1
		else:
			r = 1
			c = n_2 + 1
		print('white')
		print('1 2')
	else:
		print('black')
main()


import sys
import os
from math import sqrt, gcd, ceil, log, floor, sin, pi
from math import factorial as fact
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
from itertools import permutations
input = sys.stdin.readline

def read():
	return list(map(int, input().strip().split()))

def read_f():
	return list(map(float, input().strip().split()))
MOD = 10 ** 9 + 7

def build(arr):
	n = len(arr)
	tree = [[0, 0] for i in range(2 * n - 1)]
	for i in range(n):
		tree[n + i - 1][0] = arr[i]
	for i in range(n - 2, -1, -1):
		x = tree[i * 2 + 1][1]
		if x:
			tree[i][0] = tree[i * 2 + 1][0] ^ tree[i * 2 + 2][0]
			tree[i][1] = 0
		else:
			tree[i][0] = tree[i * 2 + 1][0] | tree[i * 2 + 2][0]
			tree[i][1] = 1
	return tree

def update(tree, ind, val, n):
	ind = n + ind - 1
	tree[ind][0] = val
	while ind > 0:
		par = ind - 1 >> 1
		x = tree[(par << 1) + 1][1]
		if x:
			tree[par][0] = tree[(par << 1) + 1][0] ^ tree[(par << 1) + 2][0]
		else:
			tree[par][0] = tree[(par << 1) + 1][0] | tree[(par << 1) + 2][0]
		ind = ind - 1 >> 1

def main():
	n = int(input())
	if n % 2:
		print('black')
	else:
		print('white\n1 2')
main()


n = int(input())
print(str('black' if n % 2 == 1 else 'white\n1 2'))


import os, sys, math
from io import BytesIO, IOBase
from collections import defaultdict, deque, OrderedDict
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')

def I():
	return int(input())

def In():
	return map(int, input().split())

def ln():
	return list(map(int, input().split()))

def Sn():
	return input().strip()
BUFSIZE = 8192

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return len(a)

def solve():
	n = I()
	if n & 1 == 1:
		print('black')
	else:
		print('white')
		print(1, 2)
	pass

def main():
	T = 1
	for i in range(T):
		solve()
M = 998244353
P = 1000000007

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from sys import stdin, stderr

def readInts():
	return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
	print(*args, file=stderr, **kwargs)

def solve(vs):
	return None

def run():
	(n,) = readInts()
	if n % 2 == 0:
		print('white')
		print('1 2')
	else:
		print('black')
run()


import sys
input = sys.stdin.buffer.readline
import os
n = int(input())
if n % 2 == 0:
	print('white')
	print('1 2')
else:
	print('black')


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass

def pmat(A):
	for ele in A:
		print(*ele, end='\n')
n = L()[0]
if n % 2:
	print('black')
else:
	print('white')
	print(1, 2)
endtime = time.time()


print('black' if input()[-1] in '13579' else 'white\n1 2')


from math import ceil
N = int(input())
if N % 2 == 0:
	print('white')
	print(1, 2)
else:
	print('black')


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
sys.setrecursionlimit(int(pow(10, 6)))
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
t = 1
for _ in range(t):
	n = l()[0]
	if n % 2:
		print('black')
	else:
		print('white')
		print(1, 2)


import sys
n = int(input())
if n % 2 == 1:
	print('black')
else:
	print('white')
	print('1 2')


a = int(input())
if a % 2 == 1:
	print('black')
else:
	print('white')
	print(1, 2)


import sys
import math as mt
input = sys.stdin.buffer.readline
t = 1
for __ in range(t):
	n = int(input())
	if n % 2 != 0:
		print('black')
	else:
		print('white')
		print(1, 2)


space_numbers = int(input())
if space_numbers % 2 != 0:
	print('black')
else:
	print('white')
	print('{} {}'.format(1, 2))