There is a non-negative integer array A of length N. Chef and Cook will play a game on the array with Chef starting first.

In one turn the player will perform the following operation:

Choose two indices i,j such that 1 ≤ i < j ≤ N and A_{i} > 0.
Set A_{i} ⬅ A_{i} - 1 and A_{j} ⬅ A_{j} + 1, i.e, subtract 1 from A_{i} and add 1 to A_{j}.

The player who is unable to perform the operation loses. If both Chef and Cook play optimally, who will win?

------ Input Format ------ 

- The first line of input will contain a single integer T, denoting the number of test cases.
- The first line of each test case contains a single integer N denoting the length of the array.
- The second line of teach test case contains N integers A_{1},A_{2},\ldots,A_{N} denoting the initial values of the array.

------ Output Format ------ 

For each test case, output "Chef" if Chef wins, otherwise output "Cook" (without quotes).

Each letter of the output may be printed in either uppercase or lowercase. For example, Chef, chEf, CHEF, and cHEf will all be treated as equivalent.

------ Constraints ------ 

$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 100$
$0 ≤ A_{i} ≤ 10^{9}$
- There are no limits on the sum of $N$ over all test cases.

----- Sample Input 1 ------ 
3
4
1 0 1 0
4
1 2 3 4
1
420

----- Sample Output 1 ------ 
Chef
Chef
Cook

----- explanation 1 ------ 
For the first test case, Chef wins. Here is the strategy for Chef.

- Initially, $A = [1, 0, 1, 0]$.
- In the first turn, Chef will pick $i=1$ and $j=3$. Then, $A = [0,0,2,0]$.
- In the second turn, Cook is can only pick $i=3$ and $j=4$. Then $A=[0,0,1,1]$.
- In the third turn, Chef will pick $i=3$ and $j=4$. Then $A=[0,0,0,2]$.
- In the fourth turn, Cook cannot perform any operation and loses. Therefore, Chef has won.

Difficulty: MEDIUM_HARD
Tags: Game theory

Starter code:

Solutions:
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [int(j) for j in input().split()]
	ans = 0
	for i in range(n):
		ans = ans ^ arr[i] % 2 * (n - i - 1)
	if ans == 0:
		print('Cook')
	else:
		print('Chef')


for i in range(int(input())):
	n = int(input())
	lst = [int(val) for val in input().split()]
	res = 0
	for i in range(n):
		res = res ^ (n - i - 1) * (lst[i] % 2)
	print('Cook' if res == 0 else 'Chef')


for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	x = 0
	for i in range(n - 1):
		if a[i] & 1:
			x ^= n - i - 1
	print('Chef' if x else 'Cook')


import collections as clts
import math
import heapq

def gcd(x, y):
	if y == 0:
		return x
	else:
		return gcd(y, x % y)

def lcm(x, y):
	return int(x / gcd(x, y) * y)
for _ in range(int(input())):
	N = int(input())
	A = list(map(int, input().split()))
	stones = N - 1
	moves = 0
	for i in range(N):
		if A[i] % 2 == 0:
			moves ^= 0
		else:
			moves ^= stones
		stones -= 1
	if moves != 0:
		print('Chef')
	else:
		print('Cook')


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	c = 0
	for i in range(n - 1):
		if a[i] % 2 != 0:
			c ^= n - i - 1
	if c <= 0:
		print('Cook')
	else:
		print('Chef')


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	temp = 0
	for i in range(n - 1):
		if l[i] % 2 == 1:
			temp = temp ^ n - i - 1
	if temp:
		print('Chef')
	else:
		print('Cook')


test_cases = int(input())
for i in range(test_cases):
	n = int(input())
	arr = [int(x) for x in input().split()]
	temp = 0
	for i in range(n - 1):
		if arr[i] % 2 == 1:
			temp = temp ^ n - i - 1
	if temp == 0:
		print('Cook')
	else:
		print('Chef')


t = int(input())
for i in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	x = 0
	for i in range(n - 1):
		if a[i] % 2 == 1:
			x = x ^ n - i - 1
	if x == 0:
		print('Cook')
	else:
		print('Chef')


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

def li():
	return list(mi())

def si():
	return str(input())

def ni():
	return int(input())
for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	ans = 0
	for i in range(n):
		if a[i] % 2 == 1:
			ans ^= n - i - 1
	if ans == 0:
		print('Cook')
	else:
		print('Chef')


t = int(input())
for o in range(t):
	n = int(input())
	arr = [k for k in map(int, input().split())]
	xsum = 0
	for i in range(0, n):
		if arr[i] % 2 == 1:
			xsum = xsum ^ n - (i + 1)
	if xsum != 0:
		print('Chef')
	else:
		print('Cook')


import time
import sys
import math
from collections import defaultdict as dd
from functools import lru_cache
inty = lambda : int(input())
stringy = lambda : input().strip()
mappy = lambda : map(int, input().strip().split())
fmappy = lambda : map(float, input().strip().split())
listy = lambda : list(map(int, input().strip().split()))
tick = lambda : time.perf_counter()
T = inty()
for _ in range(T):
	n = inty()
	alist = listy()
	xor = 0
	for i in range(n - 1):
		if alist[i] & 1:
			xor ^= n - 1 - i
	print('Chef' if xor > 0 else 'Cook')


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	ans = 0
	for (i, el) in enumerate(a):
		ans ^= n - i - 1 if el & 1 else 0
	print('Chef' if ans else 'Cook')


T = int(input())
for _ in range(T):
	n = int(input())
	alist = list(map(int, input().split()))
	x = 0
	for i in range(n):
		if alist[i] & 1:
			x ^= n - i - 1
	print('Chef' if x > 0 else 'Cook')


testcase = int(input())
for _ in range(testcase):
	n = int(input())
	arr = [int(num) for num in input().split()]
	ans = 0
	for (ind, num) in enumerate(arr[:-1]):
		ans ^= (n - ind - 1) * (arr[ind] % 2)
	print('Chef' if ans else 'Cook')


from functools import reduce
for _ in range(int(input())):
	N = int(input())
	A = [N - i - 1 for (i, s) in enumerate(input().split()) if int(s) & 1]
	print('Chef' if reduce(int.__xor__, A, 0) else 'Cook')


for i in range(int(input())):
	N = int(input())
	A = [int(x) for x in input().split()]
	ans = 0
	p = N - 1
	for j in range(N):
		if A[j] % 2 == 1:
			ans ^= p
		p -= 1
	if ans == 0:
		print('Cook')
	else:
		print('Chef')


a = 1
b = 0
for _ in range(int(input())):
	n = int(input())
	(i, p) = [n - a, b]
	for t in list(map(int, input().split())):
		if t % (a + a) == a:
			p ^= i
		i -= 1 * a + b
	if p == b:
		print('Cook')
	else:
		print('Chef')


for _ in range(int(input())):
	n = int(input())
	pranav = 0
	(i, p) = [n - 1, 0]
	for KKKT in range(10000):
		pranav = pranav + 1.5
	for t in list(map(int, input().split())):
		if t % 2 == 1:
			p ^= i
		i -= 1
	if p == 0:
		print('Cook')
	else:
		print('Chef')


t = int(input())
for k in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	xor = 0
	for i in range(n):
		if arr[i] % 2 != 0:
			xor ^= n - i - 1
	if xor == 0:
		print('Cook')
	else:
		print('Chef')


for _ in range(int(input())):
	n = int(input())
	(i, p) = [n - 1, 0]
	for t in list(map(int, input().split())):
		if t % 2 == 1:
			p ^= i
		i -= 1
	if p == 0:
		print('Cook')
	else:
		print('Chef')

def fun():
	a = 1
	a = 2
	a = 1
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2
	a = 1
	a = 2


t = int(input())
for _ in range(t):
	n = int(input())
	list1 = list(map(int, input().split()))
	list1.reverse()
	x = 0
	for i in range(n - 1, -1, -1):
		if list1[i] % 2 == 1:
			x = x ^ i
	if x == 0:
		print('Cook')
	else:
		print('Chef')


import numpy
import math
test = int(input())
for _ in range(test):
	n = int(input())
	a = list(map(int, input().split()))
	x = 0
	j = 0
	for i in range(n - 1, 0, -1):
		if a[j] % 2 == 1:
			x = x ^ i
		j += 1
	if x == 0:
		print('Cook')
	else:
		print('Chef')


from collections import Counter, deque, defaultdict, OrderedDict
import math
from bisect import bisect, bisect_left
import sys
import re
MOD = 10 ** 9 + 7
MAX = -sys.maxsize
MIN = sys.maxsize

class get:

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

	def str():
		return input().split()

	def float():
		return list(map(float, input().split()))

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

def sqrt(x):
	return int(math.sqrt(x)) + 1

def gcd(*args):
	result = args[0]
	for item in args:
		result = math.gcd(result, item)
	return result

def LCM(a, b):
	return a * b // math.gcd(a, b)

def isPrime(n):
	if n == 1:
		return False
	for i in range(2, sqrt(n)):
		if n % i == 0:
			return False
	return True

def solve():
	n = int(input())
	a = get.int()
	a = a[::-1]
	x = 0
	for i in range(n - 1, -1, -1):
		if a[i] % 2:
			x ^= i
	if x == 0:
		print('Cook')
	else:
		print('Chef')
t = int(input())
for tt in range(t):
	solve()


import random
import math
from collections import defaultdict, Counter
from functools import lru_cache
import bisect
import heapq

class SegmentTree:

	def __init__(self, nums):
		self._size = len(nums)
		self._tree = [0] * (4 * self._size)
		self.build(nums)

	def build(self, a, v=1, lo=0, hi=None):
		if hi is None:
			hi = self._size - 1
		if lo == hi:
			self._tree[v] = a[lo]
		else:
			mi = (lo + hi) // 2
			self.build(a, 2 * v, lo, mi)
			self.build(a, 2 * v + 1, mi + 1, hi)
			self._tree[v] = self._tree[2 * v] + self._tree[2 * v + 1]

	def update(self, pos, val, v=1, lo=0, hi=None):
		if hi is None:
			hi = self._size - 1
		if lo == hi:
			self._tree[v] = val
		else:
			mi = (lo + hi) // 2
			if pos <= mi:
				self.update(pos, val, 2 * v, lo, mi)
			else:
				self.update(pos, val, 2 * v + 1, mi + 1, hi)
			self._tree[v] = self._tree[2 * v] + self._tree[2 * v + 1]

	def query(self, l, h, v=1, lo=0, hi=None):
		if hi is None:
			hi = self._size - 1
		if l > h:
			return 0
		elif l == lo and h == hi:
			return self._tree[v]
		else:
			mi = (lo + hi) // 2
			return self.query(l, min(mi, h), 2 * v, lo, mi) + self.query(max(mi + 1, l), h, 2 * v + 1, mi + 1, hi)

class UnionFind:

	def __init__(self, n):
		self.n = n
		self.parents = list(range(n))

	def find(self, x):
		if self.parents[x] == x:
			return x
		else:
			self.parents[x] = self.find(self.parents[x])
			return self.parents[x]

	def union(self, x, y):
		x = self.find(x)
		y = self.find(y)
		if x != y:
			self.parents[x] = y
dire = [0, 1, 0, -1, 0]

def is_prime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def google(t):
	print('Case #{}:'.format(t), end=' ')
RANDOM = random.randrange(2 ** 62)

def Wrapper(x):
	return x ^ RANDOM

def solve():
	n = int(input())
	a = list(map(int, input().split()))[::-1]
	flag = 0
	for i in range(n - 1, -1, -1):
		if a[i] % 2 == 1:
			flag ^= i
	if flag == 0:
		print('Cook')
	else:
		print('Chef')
for t in range(int(input())):
	solve()


t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().rstrip().split()))
	x = 0
	for (i, ele) in enumerate(reversed(arr)):
		if ele % 2 == 1:
			x = x ^ i
	print('Cook') if x == 0 else print('Chef')


t = int(input())
while t > 0:
	n = int(input())
	a = list(map(int, input().split()))
	x = 0
	a.reverse()
	for i in range(n - 1, -1, -1):
		if a[i] % 2 == 1:
			x = x ^ i
	if x == 0:
		print('Cook')
	else:
		print('Chef')
	t = t - 1


def test():
	n = int(input())
	l = list(map(int, input().split()))
	l.reverse()
	r = 0
	for i in range(n):
		if l[i] % 2 == 1:
			r ^= i
	if r == 0:
		print('Cook')
	else:
		print('Chef')
t = int(input())
for _ in range(t):
	test()


def solve():
	n = int(input())
	A = list(map(int, input().split()))
	(ans, lt) = (0, 0)
	for i in range(n - 1, -1, -1):
		if A[lt] % 2 == 1:
			ans ^= i
		lt += 1
	return 'Cook' if ans == 0 else 'Chef'
for _ in range(int(input())):
	print(solve())


t = int(input())
for l in range(t):
	input()
	cnt = 0
	listx = list(map(int, input().split()))
	listx = listx[::-1]
	for m in range(len(listx)):
		if listx[m] % 2 == 1:
			cnt ^= m
	if cnt == 0:
		print('Cook')
	else:
		print('Chef')


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.reverse()
	ans = 0
	for j in range(n):
		if a[j] % 2 != 0:
			ans ^= j
	if ans == 0:
		print('Cook')
	else:
		print('Chef')


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))[::-1]
	cnt = 0
	for i in range(n - 1, -1, -1):
		if arr[i] % 2 == 1:
			cnt = cnt ^ i
	print('Cook' if cnt == 0 else 'Chef')


T = int(input())
for t in range(T):
	n = int(input())
	l = list(map(int, input().split()))
	x = 0
	for i in range(n):
		if l[i] % 2 == 1:
			x ^= n - i - 1
	if x == 0:
		print('Cook')
	else:
		print('Chef')


for _ in range(int(input())):
	a = int(input())
	aa = list(map(int, input().split()))
	x = 0
	cd = aa[::-1]
	for i in reversed(range(a)):
		if cd[i] % 2 == 1:
			x ^= i
	if x != 0:
		print('Chef')
	else:
		print('Cook')


def gcd(a, b):
	if b == 0:
		return a
	return gcd(a % b, a)

def swap(a, b):
	(a, b) = (b, a)
	return (a, b)

def fact(n):
	if n == 1:
		return 1
	return n * fact(n - 1)

def cbits(n):
	count = 0
	while n:
		n = n & n - 1
		count += 1
	return count

def solve(n, arr):
	c = 0
	for i in range(n - 1, -1, -1):
		if arr[i] % 2 == 1:
			c = c ^ i
	if c == 0:
		print('Cook')
	else:
		print('Chef')
t = int(input())
while t > 0:
	n = int(input())
	arr = list(map(int, input().split()))
	arr = arr[::-1]
	solve(n, arr)
	t -= 1


T = int(input())
for _ in range(T):
	N = int(input())
	arr = list(map(int, input().split()))
	arr.reverse()
	x = 0
	for i in range(N - 1, -1, -1):
		if arr[i] % 2 == 1:
			x ^= i
	if x == 0:
		print('Cook')
	else:
		print('Chef')


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a = a[::-1]
	p = 0
	for x in range(n):
		if a[x] & 1:
			p ^= x
	if not p:
		print('Cook')
	else:
		print('Chef')