Koa the Koala and her best friend want to play a game.

The game starts with an array $a$ of length $n$ consisting of non-negative integers. Koa and her best friend move in turns and each have initially a score equal to $0$. Koa starts.

Let's describe a move in the game:  During his move, a player chooses any element of the array and removes it from this array, xor-ing it with the current score of the player.

 More formally: if the current score of the player is $x$ and the chosen element is $y$, his new score will be $x \oplus y$. Here $\oplus$ denotes bitwise XOR operation.

 Note that after a move element $y$ is removed from $a$.

  The game ends when the array is empty. 

At the end of the game the winner is the player with the maximum score. If both players have the same score then it's a draw.

If both players play optimally find out whether Koa will win, lose or draw the game.


-----Input-----

Each test contains multiple test cases. The first line contains $t$ ($1 \le t \le 10^4$) — the number of test cases. Description of the test cases follows.

The first line of each test case contains the integer $n$ ($1 \le n \le 10^5$) — the length of $a$.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 10^9$) — elements of $a$.

It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.


-----Output-----

For each test case print:  WIN if Koa will win the game.  LOSE if Koa will lose the game.  DRAW if the game ends in a draw. 


-----Examples-----
Input
3
3
1 2 2
3
2 2 3
5
0 0 0 2 2

Output
WIN
LOSE
DRAW

Input
4
5
4 1 5 1 3
4
1 0 1 6
1
0
2
5 4

Output
WIN
WIN
DRAW
WIN



-----Note-----

In testcase $1$ of the first sample we have:

$a = [1, 2, 2]$. Here Koa chooses $1$, other player has to choose $2$, Koa chooses another $2$. Score for Koa is $1 \oplus 2 = 3$ and score for other player is $2$ so Koa wins.

Difficulty: HARD
Tags: Bit manipulation

Constructive algorithms

Greedy algorithms

Dynamic programming

Game theory

Mathematics
Skill types: Dynamic programming

Bit manipulation

Greedy algorithms

Starter code:

Solutions:
import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	ar = [int(x) for x in input().split()]
	bit = [0] * 32
	dr = True
	for i in range(32):
		for j in ar:
			bit[i] += 1 if 1 << i & j else 0
	bit = bit[::-1]
	for i in bit:
		if i % 2 != 0:
			dr = False
			if i % 4 == 3 and (n - i) % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			break
	if dr:
		print('DRAW')


from collections import defaultdict
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange

def print_case_iterable(case_num, iterable):
	print('Case #{}: {}'.format(case_num, ' '.join(map(str, iterable))))

def print_case_number(case_num, iterable):
	print('Case #{}: {}'.format(case_num, iterable))

def print_iterable(A):
	print(' '.join(A))

def read_int():
	return int(f.readline().strip())

def read_int_array():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def read_string():
	return list(f.readline().strip())

def ri():
	return int(f.readline().strip())

def ria():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def rs():
	return list(f.readline().strip())

def bi(x):
	return bin(x)[2:]
from collections import deque
import math
NUMBER = 10 ** 9 + 7

def factorial(n):
	M = NUMBER
	f = 1
	for i in range(1, n + 1):
		f = f * i % M
	return f

def mult(a, b):
	return a * b % NUMBER

def minus(a, b):
	return (a - b) % NUMBER

def plus(a, b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a):
	m = NUMBER
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m

def choose(n, k):
	if n < k:
		assert false
	return mult(factorial(n), modinv(mult(factorial(k), factorial(n - k)))) % NUMBER
from collections import deque, defaultdict
import heapq
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc

def get_num_2_5(n):
	twos = 0
	fives = 0
	while n > 0 and n % 2 == 0:
		n //= 2
		twos += 1
	while n > 0 and n % 5 == 0:
		n //= 5
		fives += 1
	return (twos, fives)

def shift(a, i, num):
	for _ in range(num):
		(a[i], a[i + 1], a[i + 2]) = (a[i + 2], a[i], a[i + 1])

def equal(x, y):
	return abs(x - y) <= 1e-09

def getAngle(a, b, c):
	ang = math.degrees(math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0]))
	return ang + 360 if ang < 0 else ang

def getLength(a, b):
	return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
from heapq import heapify, heappush, heappop
from string import ascii_lowercase as al

def solution(a, n):
	draw = True
	for i in range(50, -1, -1):
		cnt = 0
		for x in a:
			if 1 << i & x:
				cnt += 1
		if cnt % 2:
			draw = False
			break
	if draw:
		return 'DRAW'
	if (cnt - 1) % 4 == 0:
		return 'WIN'
	win = (cnt + 1) // 2 % 2
	win = win ^ (n - cnt) % 2
	return 'WIN' if win else 'LOSE'

def main():
	for i in range(int(input())):
		n = int(input())
		a = list(map(int, input().split()))
		x = solution(a, n)
		if 'xrange' not in dir(__builtins__):
			print(x)
		else:
			(print >> output, 'Case #' + str(i + 1) + ':', str(x))
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()
if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
main()


from collections import defaultdict
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange

def print_case_iterable(case_num, iterable):
	print('Case #{}: {}'.format(case_num, ' '.join(map(str, iterable))))

def print_case_number(case_num, iterable):
	print('Case #{}: {}'.format(case_num, iterable))

def print_iterable(A):
	print(' '.join(A))

def read_int():
	return int(f.readline().strip())

def read_int_array():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def read_string():
	return list(f.readline().strip())

def ri():
	return int(f.readline().strip())

def ria():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def rs():
	return list(f.readline().strip())

def bi(x):
	return bin(x)[2:]
from collections import deque
import math
NUMBER = 10 ** 9 + 7

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)
from collections import deque, defaultdict
import heapq
from types import GeneratorType

def shift(a, i, num):
	for _ in range(num):
		(a[i], a[i + 1], a[i + 2]) = (a[i + 2], a[i], a[i + 1])
from heapq import heapify, heappush, heappop
from string import ascii_lowercase as al

def solution(a, n):
	draw = True
	for i in range(50, -1, -1):
		cnt = 0
		for x in a:
			if 1 << i & x:
				cnt += 1
		if cnt % 2:
			draw = False
			break
	if draw:
		return 'DRAW'
	if (cnt - 1) % 4 == 0:
		return 'WIN'
	win = (cnt + 1) // 2 % 2
	win = win ^ (n - cnt) % 2
	return 'WIN' if win else 'LOSE'

def main():
	for i in range(int(input())):
		n = int(input())
		a = list(map(int, input().split()))
		x = solution(a, n)
		if 'xrange' not in dir(__builtins__):
			print(x)
		else:
			(print >> output, 'Case #' + str(i + 1) + ':', str(x))
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()
if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
main()


class B:

	@staticmethod
	def input():
		n = int(input())
		nums = input()
		return (n, nums)

	def __init__(self, n=None, nums=None):
		if n is None:
			(n, nums) = B.input()
		self.n = n
		self.nums = [int(x) for x in nums.split()]
		self.totxor = 0
		for num in self.nums:
			self.totxor ^= num
		self.maxbit = -1
		for (pw, val) in enumerate(format(self.totxor, '031b')[::-1]):
			if val == '1':
				self.maxbit = pw
		self.nums = [format(x, '031b')[::-1][self.maxbit] for x in self.nums]

	def solve(self):
		if self.totxor == 0:
			print('DRAW')
			return 'DRAW'
		one_nr = self.nums.count('1')
		zer_nr = self.n - one_nr
		win = 'WIN'
		lose = 'LOSE'
		if one_nr % 4 == 3 and zer_nr % 2 == 1:
			print(win)
			return 'WIN'
		if one_nr % 4 == 3 and zer_nr % 2 == 0:
			print(lose)
			return 'LOSE'
		else:
			print(win)
			return 'WIN'
for _ in range(int(input())):
	B().solve()


from math import log2
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	lis = list(map(int, input().split()))
	maxx = max(lis)
	m = int(log2(maxx)) + 1 if maxx else 0
	x = [0] * m
	for p in lis:
		c = 0
		while p:
			if p & 1:
				x[c] += 1
			(p, c) = (p >> 1, c + 1)
	g = 0
	for i in range(m - 1, -1, -1):
		if x[i] & 1 == 0:
			continue
		if x[i] % 4 == 3 and (n - x[i]) % 2 == 0:
			g = 2
			break
		else:
			g = 1
			break
	if g == 0:
		print('DRAW')
	elif g == 1:
		print('WIN')
	else:
		print('LOSE')


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	t = [0] * 64
	for i in range(64):
		for x in a:
			t[i] += x >> i & 1
	t.reverse()
	for x in t:
		if x & 1:
			if x % 4 == 3 and (n - x) % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			break
	else:
		print('DRAW')


from collections import defaultdict
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange

def solution(a, n):
	draw = True
	for i in range(50, -1, -1):
		cnt = 0
		for x in a:
			if 1 << i & x:
				cnt += 1
		if cnt % 2:
			draw = False
			break
	if draw:
		return 'DRAW'
	if (cnt - 1) % 4 == 0:
		return 'WIN'
	win = (cnt + 1) // 2 % 2
	win = win ^ (n - cnt) % 2
	return 'WIN' if win else 'LOSE'

def main():
	for i in range(int(input())):
		n = int(input())
		a = list(map(int, input().split()))
		x = solution(a, n)
		if 'xrange' not in dir(__builtins__):
			print(x)
		else:
			(print >> output, 'Case #' + str(i + 1) + ':', str(x))
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()
if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
main()


def solution(n, arr):
	nums = {}
	for el in arr:
		if el in nums:
			nums[el][1] += 1
		else:
			nums[el] = [el, 1]
	if 0 in nums:
		del nums[0]
	order_num = 2 ** 29
	(del_els, k) = ([], 0)
	while nums:
		for el in nums:
			if nums[el][0] >= order_num:
				k += nums[el][1]
				nums[el][0] -= order_num
				if not nums[el][0]:
					del_els.append(el)
		for el in del_els:
			del nums[el]
		if k % 2:
			return 'WIN' if k % 4 == 1 or (n - k) % 2 else 'LOSE'
		k = 0
		del_els.clear()
		order_num >>= 1
	return 'DRAW'
for test_i in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	print(solution(n, arr))


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	v = len(bin(max(a))) - 2
	f = 1
	z = ['0' * (v + 2 - len(bin(i))) + bin(i)[2:] for i in a]
	for i in range(v):
		b = 0
		for j in z:
			if j[i] == '1':
				b += 1
		if b % 2:
			if b // 2 % 2 and n % 2:
				print('LOSE')
			else:
				print('WIN')
			f = 0
			break
	if f:
		print('DRAW')


import sys
input = sys.stdin.readline
d = {1: 'WIN', 0: 'LOSE', -1: 'DRAW'}

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		a = map(int, input().split())
		f = [0] * 30
		for x in a:
			for b in range(30):
				if x >> b & 1:
					f[b] += 1
		ans = -1
		for x in reversed(range(30)):
			if f[x] % 2 == 1:
				ans = 0 if f[x] % 4 == 3 and (n - f[x]) % 2 == 0 else 1
				break
		print(d[ans])
main()


import sys
input = sys.stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
L = lambda : list(R())
for _ in range(I()):
	n = I()
	a = L()
	cnt = [0] * 30
	for x in a:
		for j in range(30):
			if x & 1 << j:
				cnt[j] += 1
	ans = 'DRAW'
	for j in range(29, -1, -1):
		if cnt[j] % 2 == 1:
			rem = n - cnt[j]
			if rem % 2 == 0 and cnt[j] % 4 == 3:
				ans = 'LOSE'
			else:
				ans = 'WIN'
			break
	print(ans)


from os import path
import sys
from heapq import heappush, heappop, heapify
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input().rstrip()

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

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('a')
file = 1

def solve():
	for _ in range(ii()):
		n = ii()
		a = li()
		x = 0
		for i in a:
			x ^= i
		if x == 0:
			print('DRAW')
			continue
		for i in range(30, -1, -1):
			if x >> i & 1:
				one = 0
				zero = 0
				for j in a:
					if j >> i & 1:
						one += 1
					else:
						zero += 1
				if zero % 2 == 0 and one % 4 == 3:
					print('LOSE')
				else:
					print('WIN')
				break
if file:
	if path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	else:
		input = sys.stdin.readline
solve()


import sys
sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

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

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]
for _ in range(II()):
	n = II()
	aa = LI()
	for k in range(32, -1, -1):
		cnt = 0
		for a in aa:
			cnt += a >> k & 1
		if cnt & 1:
			break
	else:
		print('DRAW')
		continue
	if cnt % 4 == 3 and (n - cnt) % 2 == 0:
		print('LOSE')
	else:
		print('WIN')


import sys
import math
from heapq import *
input = sys.stdin.readline
from functools import cmp_to_key

def pi():
	return int(input())

def pl():
	return int(input(), 16)

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

def ts():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
mod = 1000000007
f = []

def fact(n, m):
	global f
	f = [1 for i in range(n + 1)]
	f[0] = 1
	for i in range(1, n + 1):
		f[i] = f[i - 1] * i % m

def fast_mod_exp(a, b, m):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b = b >> 1
	return res

def inverseMod(n, m):
	return fast_mod_exp(n, m - 2, m)

def ncr(n, r, m):
	if n < 0 or r < 0 or r > n:
		return 0
	if r == 0:
		return 1
	return f[n] * inverseMod(f[n - r], m) % m * inverseMod(f[r], m) % m

def main():
	B()

def B():
	t = pi()
	while t:
		t -= 1
		(n, a) = (pi(), ti())
		x = int(math.pow(2, 30))
		f = 0
		for i in range(31):
			c = 0
			for j in range(n):
				if x & int(a[j]) != 0:
					c += 1
			if c % 2 != 0:
				if c % 4 == 1:
					print('WIN')
				elif (n - c) % 2 != 0:
					print('WIN')
				else:
					print('LOSE')
				f = 1
				break
			x = x >> 1
		if f == 0:
			print('DRAW')
main()


from collections import defaultdict
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange

def print_case_iterable(case_num, iterable):
	print('Case #{}: {}'.format(case_num, ' '.join(map(str, iterable))))

def print_case_number(case_num, iterable):
	print('Case #{}: {}'.format(case_num, iterable))

def print_iterable(A):
	print(' '.join(A))

def read_int():
	return int(f.readline().strip())

def read_int_array():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def read_string():
	return list(f.readline().strip())

def ri():
	return int(f.readline().strip())

def ria():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def rs():
	return list(f.readline().strip())

def bi(x):
	return bin(x)[2:]
from collections import deque
import math
NUMBER = 10 ** 9 + 7

def factorial(n):
	M = NUMBER
	f = 1
	for i in range(1, n + 1):
		f = f * i % M
	return f

def mult(a, b):
	return a * b % NUMBER

def minus(a, b):
	return (a - b) % NUMBER

def plus(a, b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a):
	m = NUMBER
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m

def choose(n, k):
	if n < k:
		assert false
	return mult(factorial(n), modinv(mult(factorial(k), factorial(n - k)))) % NUMBER
from collections import deque, defaultdict
import heapq
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc

def dfs(g, timeIn, timeOut, depths, parents):
	cnt = 0
	stack = [[1, 0, 0, 0]]
	while stack:
		(v, neig_i, parent, depth) = stack[-1]
		parents[v] = parent
		depths[v] = depth
		if neig_i == 0:
			timeIn[v] = cnt
			cnt += 1
		while neig_i < len(g[v]):
			u = g[v][neig_i]
			if u == parent:
				neig_i += 1
				continue
			stack[-1][1] = neig_i + 1
			stack.append([u, 0, v, depth + 1])
			break
		if neig_i == len(g[v]):
			stack.pop()
			timeOut[v] = cnt
			cnt += 1
cnt = 0

@bootstrap
def dfs(v, adj, timeIn, timeOut, depths, parents, parent=0, depth=0):
	global cnt
	parents[v] = parent
	depths[v] = depth
	timeIn[v] = cnt
	cnt += 1
	for u in adj[v]:
		if u == parent:
			continue
		yield dfs(u, adj, timeIn, timeOut, depths, parents, v, depth + 1)
	timeOut[v] = cnt
	cnt += 1
	yield

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

def lcm(a, b):
	return a * b / gcd(a, b)

def get_num_2_5(n):
	twos = 0
	fives = 0
	while n > 0 and n % 2 == 0:
		n //= 2
		twos += 1
	while n > 0 and n % 5 == 0:
		n //= 5
		fives += 1
	return (twos, fives)

def shift(a, i, num):
	for _ in range(num):
		(a[i], a[i + 1], a[i + 2]) = (a[i + 2], a[i], a[i + 1])

def equal(x, y):
	return abs(x - y) <= 1e-09

def getAngle(a, b, c):
	ang = math.degrees(math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0]))
	return ang + 360 if ang < 0 else ang

def getLength(a, b):
	return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
from heapq import heapify, heappush, heappop

def bfs(adj):
	s = set()
	d = defaultdict(set)
	q = deque([])
	s.add(0)
	d[0].add(0)
	q.append((0, 0))
	while len(q) > 0:
		(v, depth) = q.popleft()
		for u in adj[v]:
			if u not in s:
				s.add(u)
				d[depth + 1].add(u)
				q.append((u, depth + 1))
	return d

@bootstrap
def dfs(u, top, adj, vis):
	vis[u] = 1
	for (v, d) in adj[u]:
		if vis[v] == 2 or d == 0:
			continue
		if vis[v] == 1:
			yield 'No'
		x = (yield dfs(v, top, adj, vis))
		if x == 'No':
			yield 'No'
	vis[u] = 2
	top.append(u)
	yield

def isSubsetSum(arr, n, summ):
	subarr = [[False for i in range(summ + 1)] for i in range(n + 1)]
	for i in range(n + 1):
		subarr[i][0] = True
	for i in range(1, summ + 1):
		subarr[0][i] = False
	for i in range(1, n + 1):
		for j in range(1, summ + 1):
			if j < arr[i - 1]:
				subarr[i][j] = subarr[i - 1][j]
			if j >= arr[i - 1]:
				subarr[i][j] = subarr[i - 1][j] or subarr[i - 1][j - arr[i - 1]]
	return subarr[n][summ]

def find_lcm(a, b):
	return a * b // gcd(a, b)

def find_lcm_array(A):
	if len(A) == 1:
		return A[0]
	lcm = find_lcm(A[0], A[1])
	for i in range(2, len(A)):
		lcm = find_lcm(lcm, A[i])
	return lcm
from string import ascii_lowercase as al

def solution(a, n):
	draw = True
	for i in range(50, -1, -1):
		cnt = 0
		for x in a:
			if 1 << i & x:
				cnt += 1
		if cnt % 2:
			draw = False
			break
	if draw:
		return 'DRAW'
	if (cnt - 1) % 4 == 0:
		return 'WIN'
	win = (cnt + 1) // 2 % 2
	win = win ^ (n - cnt) % 2
	return 'WIN' if win else 'LOSE'

def main():
	T = 1
	T = ri()
	for i in range(T):
		n = ri()
		a = ria()
		x = solution(a, n)
		if 'xrange' not in dir(__builtins__):
			print(x)
		else:
			(print >> output, 'Case #' + str(i + 1) + ':', str(x))
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()
if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
main()


loop = int(input())
result = []
for y in range(0, loop):
	l = int(input())
	arr = list(map(int, input().split()))
	p1 = 0
	p2 = 0
	for j in range(30, -1, -1):
		sum = 0
		for i in range(0, l):
			if arr[i] & 1 << j:
				sum = sum + 1
		if sum % 2 == 1:
			if sum % 4 == 1:
				p1 = 1
			elif l % 2 == 1:
				p2 = 1
			else:
				p1 = 1
			break
	if p1 > p2:
		result.append('WIN')
	elif p2 > p1:
		result.append('LOSE')
	else:
		result.append('DRAW')
print(*result, sep='\n')


import io
import os
from collections import Counter, defaultdict, deque

def solve(N, A):

	def f(pos):
		if pos < 0:
			return 'DRAW'
		zeroes = 0
		ones = 0
		for x in A:
			if x & 1 << pos:
				ones += 1
			else:
				zeroes += 1
		if ones % 2 == 0:
			return f(pos - 1)
		elif ones % 4 == 1:
			return 'WIN'
		elif ones % 4 == 3:
			if zeroes % 2 == 0:
				return 'LOSE'
			else:
				return 'WIN'
		else:
			assert False
	return f(max(A).bit_length())
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
	(N,) = [int(x) for x in input().split()]
	A = [int(x) for x in input().split()]
	ans = solve(N, A)
	print(ans)


from collections import defaultdict
for _ in range(int(input())):
	n = int(input())
	ls = list(map(int, input().split()))
	mem = defaultdict(int)
	for i in ls:
		temp = i
		cc = 0
		while temp:
			if temp % 2:
				mem[cc] += 1
			temp //= 2
			cc += 1
	flag = 0
	for i in sorted(mem.keys(), reverse=True):
		if mem[i] % 2 == 0:
			continue
		elif mem[i] % 4 == 3 and n % 2:
			print('LOSE')
			flag = 1
			break
		else:
			flag = 1
			print('WIN')
			break
	if flag == 0:
		print('DRAW')


import sys
input = sys.stdin.readline
t = int(input())
for ii in range(t):
	n = int(input())
	a = [int(i) for i in input().split() if i != '\n']
	xor = 0
	ans = [0] * 30
	for i in a:
		xor ^= i
		for j in range(30):
			if 1 << j & i != 0:
				ans[j] += 1
	if xor == 0:
		print('DRAW')
		continue
	for i in reversed(ans):
		if i % 2 == 1:
			if i % 4 == 3 and (n - i) % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			break


d = {1: 'WIN', 0: 'LOSE', -1: 'DRAW'}
t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	f = [0] * 30
	for x in a:
		for b in range(30):
			if x >> b & 1:
				f[b] += 1
	ans = -1
	for b in reversed(range(30)):
		if f[b] % 2 == 1:
			ans = 0 if f[b] % 4 == 3 and (n - f[b]) % 2 == 0 else 1
			break
	print(d[ans])


import sys
readline = sys.stdin.buffer.readline
T = int(readline())
Ans = ['DRAW'] * T
for qu in range(T):
	N = int(readline())
	A = list(map(int, readline().split()))
	for i in range(30, -1, -1):
		ma = 1 << i
		one = 0
		for idx in range(N):
			if A[idx] & ma:
				A[idx] ^= ma
				one += 1
		zero = N - one
		if one & 1:
			if zero % 2 == 0 and one % 4 == 3:
				Ans[qu] = 'LOSE'
			else:
				Ans[qu] = 'WIN'
			break
print('\n'.join(Ans))


for _ in range(int(input())):
	n = int(input())
	ls = list(map(int, input().split()))
	bit = 32
	check = True
	while bit >= 0 and check:
		x = 0
		for i in ls:
			if i & 1 << bit:
				x += 1
		y = n - x
		if not x & 1:
			bit -= 1
		else:
			check = False
			if x % 4 == 1:
				print('WIN')
			elif y % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
	if check:
		print('DRAW')


t = int(input())
for _ in range(t):
	l = int(input())
	nums = list(map(int, input().split()))
	x = [0] * 30
	for n in nums:
		for bit in range(30):
			temp = n >> bit
			x[bit] += temp & 1
	x = x[::-1]
	score = 'draw'
	for bit in range(30):
		if x[bit] % 2 == 1:
			if x[bit] % 4 == 3 and (l - x[bit]) % 2 == 0:
				score = 'lose'
			else:
				score = 'win'
			break
	print(score.upper())


import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
con = 10 ** 9 + 7
INF = float('inf')

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

def main():
	T = int(input())
	for _ in range(T):
		N = int(input())
		A = getlist()
		A.sort()
		XOR = 0
		for i in range(N):
			XOR ^= A[i]
		if XOR == 0:
			print('DRAW')
		else:
			L = [0] * 40
			for i in range(N):
				n = A[i]
				for j in range(40):
					if n % 2 == 1:
						L[j] += 1
					n >>= 1
					if n == 0:
						break
			jud = None
			for i in range(39, -1, -1):
				if L[i] % 2 == 1:
					if L[i] % 4 == 1 or (N - L[i]) % 2 == 1:
						jud = 'WIN'
					else:
						jud = 'LOSE'
					break
			print(jud)
main()


def find(A):
	M = max(A)
	s = bin(M)[2:]
	L = len(s)
	A_temp = []
	for x in A:
		temp = bin(x)[2:]
		temp = '0' * (L - len(temp)) + temp
		A_temp += [temp]
	N = len(A)
	for i in range(L):
		count = 0
		for x in A_temp:
			count += int(x[i])
		if count % 2 == 1:
			if count % 4 == 1:
				return 'WIN'
			else:
				zeros = N - count
				if zeros % 2 == 0:
					return 'LOSE'
				else:
					return 'WIN'
	return 'DRAW'
ANS = []
for _ in range(int(input())):
	input()
	A = list(map(int, input().strip().split()))
	ANS += [find(A)]
print('\n'.join(ANS))


T = int(input())
for _ in range(T):
	N = int(input())
	A = list(map(int, input().split()))
	bits = [0] * 32
	for a in A:
		for i in range(31, -1, -1):
			if a & 1 << i:
				bits[i] += 1
	for b in reversed(bits):
		if b % 4 == 1:
			print('WIN')
			break
		if b % 4 == 3:
			print('LOSE' if N % 2 else 'WIN')
			break
	else:
		print('DRAW')


import sys
import math
from collections import defaultdict
import heapq

def getnum(num):
	cnt = 0
	ans = 0
	while 1 << cnt <= num:
		ans = cnt
		cnt += 1
	if num == 0:
		return 0
	return ans + 1
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	arr = list(map(int, sys.stdin.readline().split()))
	mp = [[] for x in range(31)]
	last = []
	for i in range(n):
		x = getnum(arr[i])
		mp[x].append(arr[i])
		last.append(x)
	last.sort()
	rem = n
	z = True
	for i in range(30, 0, -1):
		if len(mp[i]) != 0:
			y = len(mp[i])
			rem = n - y
			if y == 1:
				z = False
				print('WIN')
				break
			if y % 2 != 0:
				if rem % 2 == 0:
					first = (y + 1) // 2
					second = y // 2
					if first % 2 != 0:
						print('WIN')
					else:
						print('LOSE')
					z = False
					break
				if rem % 2 != 0:
					print('WIN')
					z = False
					break
			else:
				for j in range(y):
					mp[i][j] %= 1 << i - 1
					x = getnum(mp[i][j])
					mp[x].append(mp[i][j])
		else:
			continue
	if z:
		print('DRAW')


T = int(input())
for _ in range(0, T):
	n = int(input())
	s = [int(x) for x in input().split()]
	pos = [0] * 35
	for i in range(0, len(s)):
		tt = bin(s[i])[2:]
		tt = '0' * (35 - len(tt)) + tt
		for j in range(35):
			pos[j] += int(tt[j])
	ans = 'DRAW'
	turn = 0
	for i in range(0, 35):
		if pos[i] % 2 != 0:
			if pos[i] % 4 == 3 and (n - pos[i]) % 2 == 0:
				ans = 'LOSE'
			else:
				ans = 'WIN'
			break
	print(ans)


mod = 1000000007
eps = 10 ** (-9)

def main():
	import sys
	input = sys.stdin.readline
	for _ in range(int(input())):
		N = int(input())
		A = list(map(int, input().split()))
		flg = 1
		for i in range(31, -1, -1):
			cnt = 0
			for a in A:
				if a >> i & 1:
					cnt += 1
			if cnt & 1:
				flg = 0
				if cnt % 4 == 1:
					print('WIN')
				elif N & 1:
					print('LOSE')
				else:
					print('WIN')
				break
		if flg:
			print('DRAW')
main()


for i in range(int(input())):
	N = int(input())
	S = list(map(int, input().split()))
	for i in range(30, -1, -1):
		count = 0
		for j in S:
			if j & 1 << i:
				count += 1
		if count % 4 == 1 or (count % 4 == 3 and N - count & 1):
			print('WIN')
			break
		elif count % 4 == 3:
			print('LOSE')
			break
	else:
		print('DRAW')


import sys
input = lambda : sys.stdin.readline().rstrip()
T = int(input())
for _ in range(T):
	N = int(input())
	A = [int(a) for a in input().split()]
	X = [0] * 30
	for a in A:
		for i in range(30):
			if a & 1 << i:
				X[i] += 1
	for i in range(30)[::-1]:
		if X[i] % 2:
			if X[i] == 1:
				print('WIN')
			elif N % 2 == 0:
				print('WIN')
			elif X[i] % 4 == 1:
				print('WIN')
			else:
				print('LOSE')
			break
	else:
		print('DRAW')


for _ in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().split()]
	s = a[0]
	for i in range(1, n):
		s ^= a[i]
	if s == 0:
		print('DRAW')
	else:
		xx = 1 << 29
		an = 0
		for i in range(30):
			c = 0
			for j in range(n):
				if a[j] & xx:
					c += 1
			if c % 2 == 1:
				if c % 4 == 1:
					an = 1
				elif n % 2 == 0:
					an = 1
				else:
					an = 0
				break
			xx = xx // 2
		if an == 1:
			print('WIN')
		else:
			print('LOSE')


for i in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	for i in range(30, -1, -1):
		cnt = 0
		for j in l:
			if j & 1 << i:
				cnt += 1
		if cnt % 4 == 1 or (cnt % 4 == 3 and n - cnt & 1):
			print('WIN')
			break
		elif cnt % 4 == 3:
			print('LOSE')
			break
	else:
		print('DRAW')


production = True
import sys, math, collections

def input(f=0, m=0):
	if m > 0:
		return [input(f) for i in range(m)]
	else:
		l = sys.stdin.readline()[:-1]
		if f >= 10:
			u = False
			f = int(str(f)[-1])
		else:
			u = True
		if f == 0:
			p = [l]
		elif f == 1:
			p = list(map(int, l.split()))
		elif f == 2:
			p = list(map(float, l.split()))
		elif f == 3:
			p = list(l)
		elif f == 4:
			p = list(map(int, list(l)))
		elif f == 5:
			p = l.split()
		return p if u else p[0]

def out(l, f=0, n=True):
	if f == 0:
		p = str(l)
	elif f == 1:
		p = ' '.join(map(str, l))
	elif f == 2:
		p = '\n'.join(map(str, l))
	elif f == 3:
		p = ''.join(map(str, l))
	print(p, end='\n' if n else '')

def log(*args):
	if not production:
		print('$$$', end='')
		print(*args)
enu = enumerate
ter = lambda a, b, c: b if a else c
ceil = lambda a, b: -(-a // b)
flip = lambda a: a + 1 & 1

def mapl(i, f=0):
	if f == 0:
		return list(map(int, i))
	elif f == 1:
		return list(map(str, i))
	elif f == 2:
		return list(map(list, i))

def solve():
	n = input(11)
	a = input(1)
	b = [0] * 32
	for i in a:
		bi = bin(i)[2:].zfill(32)
		for (p, j) in enu(bi):
			b[p] += int(j)
	y = 0
	for i in b:
		if i & 1:
			y = i
			break
	else:
		out('DRAW')
		return
	if not (y - 1) // 2 & 1:
		out('WIN')
	elif n & 1:
		out('LOSE')
	else:
		out('WIN')
	return
for i in range(input(11)):
	solve()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	base = 0
	for A in a:
		base ^= A
	if base == 0:
		print('DRAW')
	else:
		m = base.bit_length() - 1
		count = 0
		for A in a:
			count += A >> m & 1 == 1
		if n % 2 == 1:
			if count % 4 == 1:
				print('WIN')
			else:
				print('LOSE')
		else:
			print('WIN')


def DecimalToBinary(a):
	s = []
	while a >= 1:
		s.append(a % 2)
		a = a // 2
	return s

def find_sum(a, p, sum):
	for i in range(len(a)):
		if a[i] // 2 ** p > 0:
			for j in range(p):
				a[i] = a[i] // 2
			sum = sum + a[i] % 2
	return sum
t = int(input())
l = []
for i in range(t):
	n = int(input())
	sum = 0
	a = list(map(int, input().split()))
	xor = a[0]
	for i in range(1, n):
		xor = xor ^ a[i]
	xor = DecimalToBinary(xor)
	lenth = len(xor) - 1
	sum = find_sum(a, lenth, sum)
	if sum == 1:
		l.append('WIN')
	elif sum % 2 == 0:
		l.append('DRAW')
	elif (n - sum) % 2 == 0:
		if sum % 4 == 1:
			l.append('WIN')
		else:
			l.append('LOSE')
	else:
		l.append('WIN')
for i in l:
	print(i)


import sys

def input():
	return sys.stdin.buffer.readline()[:-1]
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	for i in range(29, -1, -1):
		(one, zero) = (0, 0)
		for x in a:
			if x >> i & 1:
				one += 1
			else:
				zero += 1
		if one % 2 == 0:
			continue
		else:
			if one % 4 == 3 and zero % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			break
	else:
		print('DRAW')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	ones = [0] * 40
	for i in range(40):
		for ai in a:
			ones[i] += ai >> i & 1
	for i in range(39, -1, -1):
		if ones[i] % 2 == 0:
			continue
		else:
			if ones[i] % 4 == 3 and (n - ones[i]) % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			break
	else:
		print('DRAW')


from sys import stdin
input = stdin.readline

def bit(ar, n):
	for i in range(0, 30):
		if 1 << i & n:
			ar[i] += 1
	return ar

def f(ar):
	bt = [0] * 30
	for i in ar:
		bt = bit(bt, i)
	for j in range(29, -1, -1):
		if bt[j] % 2 == 1:
			if bt[j] % 4 == 3 and (len(ar) - bt[j]) % 2 == 0:
				return 'LOSE'
			else:
				return 'WIN'
	return 'DRAW'
for i in range(int(input())):
	a = input()
	lst = list(map(int, input().strip().split()))
	print(f(lst))


def solve():
	n = int(input())
	lst = list(map(int, input().split()))
	k = 1
	while k < 10 ** 9:
		k *= 2
	num = 0
	while k and num % 2 == 0:
		num = 0
		for i in lst:
			if i % (k * 2) // k == 1:
				num += 1
		k //= 2
	if k == 0 and num % 2 == 0:
		print('DRAW')
		return 0
	if num % 4 == 1 or n % 2 == 0:
		print('WIN')
	else:
		print('LOSE')
for i in range(int(input())):
	solve()


import sys
input = sys.stdin.readline
y = lambda n, l: '0' * (l + 2 - len(bin(n))) + bin(n)[2:]
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	m = max(a)
	v = len(bin(m)) - 3
	f = 1
	aa = [y(i, v + 1) for i in a]
	for i in range(v + 1):
		b = 0
		for j in aa:
			if j[i] == '1':
				b += 1
		if b % 2:
			if b // 2 % 2:
				if n % 2:
					print('LOSE')
				else:
					print('WIN')
			else:
				print('WIN')
			f = 0
			break
	if f:
		print('DRAW')


import math as mt
import collections as cc

def binpow(n, x, m):
	n %= m
	temp = 1
	while x:
		if x & 1:
			temp *= n % m
		n *= n % m
		n >>= 1
	return temp
I = lambda : list(map(int, input().split()))
for tc in range(int(input())):
	(n,) = I()
	l = I()
	f = cc.defaultdict(int)
	ans = 'DRAW'
	for i in l:
		for j in range(30):
			if i & 1 << j:
				f[j] += 1
	for i in range(29, -1, -1):
		if f[i] % 2:
			if f[i] == 1:
				ans = 'WIN'
				break
			else:
				temp = n - f[i]
				if f[i] % 4 == 3 and temp % 2 == 0:
					ans = 'LOSE'
				else:
					ans = 'WIN'
			break
	print(ans)


import sys
readline = sys.stdin.buffer.readline
ns = lambda : readline().rstrip()
ni = lambda : int(readline().rstrip())
nm = lambda : map(int, readline().split())
nl = lambda : list(map(int, readline().split()))

def solve():
	n = ni()
	a = nl()
	t = 0
	for x in a:
		t ^= x
	if t == 0:
		print('DRAW')
		return
	m = t.bit_length() - 1
	ms = sum((1 for x in a if x & 1 << m))
	if n & 1 and ms & 2:
		print('LOSE')
	else:
		print('WIN')
	return
T = ni()
for _ in range(T):
	solve()


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(t,) = I()
for _ in range(t):
	(n,) = I()
	l = I()
	an = -1
	for i in range(30, -1, -1):
		x = 0
		y = 0
		for j in range(n):
			if l[j] >> i & 1:
				x += 1
			else:
				y += 1
		if x % 2:
			if x % 4 == 3 and y % 2 == 0:
				an = 0
			else:
				an = 1
			break
	if an != -1:
		print('LWOISNE'[an::2])
	else:
		print('DRAW')


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t1 = int(input())

def base10toN(num, base):
	(converted_string, modstring) = ('', '')
	currentnum = num
	if not num:
		return '0'
	while currentnum:
		mod = currentnum % base
		currentnum = currentnum // base
		converted_string = chr(48 + mod + 7 * (mod > 10)) + converted_string
	return converted_string
for _ in range(t1):
	n = int(input())
	a = list(map(int, input().split()))
	s = 0
	for i in range(n):
		s = s ^ a[i]
	if s == 0:
		print('DRAW')
		continue
	score = [0] * 36
	for i in range(n):
		s = base10toN(a[i], 2)
		for j in range(36 - len(s), 36):
			if s[j - 36 + len(s)] == '1':
				score[j] += 1
	for i in range(36):
		if score[i] % 2 == 0:
			continue
		if (score[i] - 1) // 2 % 2 == 1 and (n - score[i]) % 2 == 0:
			print('LOSE')
			break
		else:
			print('WIN')
			break


for _ in range(int(input())):
	n = int(input())
	li = [int(i) for i in input().split()]
	d1 = {}
	dn = False
	for i in li:
		bit = 0
		while i:
			d1[bit] = d1.get(bit, 0) + (i & 1)
			bit += 1
			i >>= 1
	for (k, v) in sorted(d1.items(), reverse=True):
		if v & 1:
			if v % 4 == 3 and n - v & 1 == 0:
				print('LOSE')
				dn = True
				break
			else:
				print('WIN')
				dn = True
				break
	if not dn:
		print('DRAW')


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	n = int(input())
	A = list(map(int, input().split()))
	XOR = 0
	ANS = [0] * 32
	for a in A:
		XOR ^= a
		for j in range(32):
			if 1 << j & a != 0:
				ANS[j] += 1
	if XOR == 0:
		print('DRAW')
		continue
	for i in range(31, -1, -1):
		if ANS[i] % 2 != 0:
			xx = ANS[i]
			yy = n - ANS[i]
			if xx % 4 == 3 and yy % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			break


T = int(input())
for _ in range(T):
	n = int(input())
	a = list(map(int, input().strip().split()))
	f = False
	for i in range(31, -1, -1):
		num = 0
		for j in range(n):
			if a[j] & 1 << i != 0:
				num += 1
		if num & 1 == 0:
			continue
		if num == n:
			if n % 4 == 1:
				print('WIN')
			else:
				print('LOSE')
		elif num % 4 == 3 and n & 1 != 0:
			print('LOSE')
		else:
			print('WIN')
		f = True
		break
	if f == False:
		print('DRAW')


def solve():
	n = int(input())
	a = list(map(int, input().split()))
	for i in range(31, -1, -1):
		k = 1 << i
		(u, v) = (0, 0)
		for j in a:
			if j & k:
				u += 1
			else:
				v += 1
		if v % 2 == 1:
			if u % 2 == 1:
				print('WIN')
				return
		elif u % 4 == 1:
			print('WIN')
			return
		elif u % 4 == 3:
			print('LOSE')
			return
	print('DRAW')
t = int(input())
for _ in range(t):
	solve()


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	x = 0
	for i in a:
		x ^= i
	if x == 0:
		print('DRAW')
		continue
	if n % 2 == 0:
		print('WIN')
		continue
	b = 0
	while 1 << b <= x:
		b += 1
	b -= 1
	c = 0
	for i in a:
		if 1 << b & i != 0:
			c += 1
	if (c - 1) // 2 % 2 == 0:
		print('WIN')
	else:
		print('LOSE')


t = int(input())
for _ in range(0, t):
	n = int(input())
	aa = [int(i) for i in input().split()]
	bits = [0] * 33
	for x in aa:
		for i in range(0, 33):
			if x >> i & 1:
				bits[i] += 1
	ans = 'DRAW'
	for i in range(len(bits) - 1, -1, -1):
		if bits[i] % 2 == 0:
			continue
		if bits[i] % 2 and bits[i] % 4 == 3 and ((n - bits[i]) % 2 == 0):
			ans = 'LOSE'
			break
		if bits[i] % 2:
			ans = 'WIN'
			break
	print(ans)


def run(n, a):
	for i in range(30, -1, -1):
		count = 0
		for j in range(n):
			count += a[j] >> i & 1
		if count % 4 == 1:
			return 'WIN'
		elif count % 2 == 1 and n % 2 == 1:
			return 'LOSE'
		elif count % 2 == 1:
			return 'WIN'
	return 'DRAW'

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		a = list(map(int, input().split()))
		ans = run(n, a)
		print(ans)
main()


import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from bisect import *
import sys

def main():
	for t in range(int(input())):
		n = int(input())
		a = list(map(int, input().split()))
		b = 0
		for i in range(n):
			b = b ^ a[i]
		if b == 0:
			print('DRAW')
		elif n == 1:
			print('WIN')
		else:
			b = [0] * 31
			for i in a:
				z = bin(i)[2:]
				for j in range(len(z)):
					if z[-(j + 1)] == '1':
						b[j] += 1
			f = 0
			for i in range(30, -1, -1):
				if b[i] % 2:
					if b[i] % 4 == 3 and (n - b[i]) % 2 == 0:
						f = 1
					break
			if f == 0:
				print('WIN')
			else:
				print('LOSE')
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from sys import stdin, stdout
fullans = ''
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	ls = list(map(int, stdin.readline().split()))
	bit = 32
	check = True
	while bit >= 0 and check:
		x = 0
		for i in ls:
			if i & 1 << bit:
				x += 1
		y = n - x
		if not x & 1:
			bit -= 1
		else:
			check = False
			if x % 4 == 1:
				fullans += 'WIN\n'
			elif y % 2 == 0:
				fullans += 'LOSE\n'
			else:
				fullans += 'WIN\n'
	if check:
		fullans += 'DRAW\n'
stdout.write(fullans)


from bisect import *
from collections import *
from math import gcd, ceil, sqrt, floor, inf
from heapq import *
from itertools import *
from operator import add, mul, sub, xor, truediv, floordiv
from functools import *
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc
farr = [1]
ifa = []

def fact(x, mod=0):
	if mod:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr) % mod)
	else:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr))
	return farr[x]

def ifact(x, mod):
	global ifa
	ifa.append(pow(farr[-1], mod - 2, mod))
	for i in range(x, 0, -1):
		ifa.append(ifa[-1] * i % mod)
	ifa = ifa[::-1]

def per(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return fact(i) // fact(i - j)
	return farr[i] * ifa[i - j] % mod

def com(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return per(i, j) // fact(j)
	return per(i, j, mod) * ifa[j] % mod

def catalan(n):
	return com(2 * n, n) // (n + 1)

def linc(f, t, l, r):
	while l < r:
		mid = (l + r) // 2
		if t > f(mid):
			l = mid + 1
		else:
			r = mid
	return l

def rinc(f, t, l, r):
	while l < r:
		mid = (l + r + 1) // 2
		if t < f(mid):
			r = mid - 1
		else:
			l = mid
	return l

def ldec(f, t, l, r):
	while l < r:
		mid = (l + r) // 2
		if t < f(mid):
			l = mid + 1
		else:
			r = mid
	return l

def rdec(f, t, l, r):
	while l < r:
		mid = (l + r + 1) // 2
		if t > f(mid):
			r = mid - 1
		else:
			l = mid
	return l

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

def binfun(x):
	c = 0
	for w in arr:
		c += ceil(w / x)
	return c

def lowbit(n):
	return n & -n

def inverse(a, m):
	a %= m
	if a <= 1:
		return a
	return (1 - inverse(m, a) * m) // a % m

class BIT:

	def __init__(self, arr):
		self.arr = arr
		self.n = len(arr) - 1

	def update(self, x, v):
		while x <= self.n:
			self.arr[x] += v
			x += x & -x

	def query(self, x):
		ans = 0
		while x:
			ans += self.arr[x]
			x &= x - 1
		return ans

class DSU:

	def __init__(self, n):
		self.c = [-1] * n

	def same(self, x, y):
		return self.find(x) == self.find(y)

	def find(self, x):
		if self.c[x] < 0:
			return x
		self.c[x] = self.find(self.c[x])
		return self.c[x]

	def union(self, u, v):
		(u, v) = (self.find(u), self.find(v))
		if u == v:
			return False
		if self.c[u] < self.c[v]:
			(u, v) = (v, u)
		self.c[u] += self.c[v]
		self.c[v] = u
		return True

	def size(self, x):
		return -self.c[self.find(x)]

class UFS:

	def __init__(self, n):
		self.parent = [i for i in range(n)]
		self.ranks = [0] * n

	def find(self, x):
		if x != self.parent[x]:
			self.parent[x] = self.find(self.parent[x])
		return self.parent[x]

	def union(self, u, v):
		(pu, pv) = (self.find(u), self.find(v))
		if pu == pv:
			return False
		if self.ranks[pu] >= self.ranks[pv]:
			self.parent[pv] = pu
			if self.ranks[pv] == self.ranks[pu]:
				self.ranks[pu] += 1
		else:
			self.parent[pu] = pv

def Prime(n):
	c = 0
	prime = []
	flag = [0] * (n + 1)
	for i in range(2, n + 1):
		if not flag[i]:
			prime.append(i)
			c += 1
		for j in range(c):
			if i * prime[j] > n:
				break
			flag[i * prime[j]] = prime[j]
			if i % prime[j] == 0:
				break
	return prime

def dij(s, graph):
	d = {}
	d[s] = 0
	heap = [(0, s)]
	seen = set()
	while heap:
		(dis, u) = heappop(heap)
		if u in seen:
			continue
		for v in graph[u]:
			if v not in d or d[v] > d[u] + graph[u][v]:
				d[v] = d[u] + graph[u][v]
				heappush(heap, (d[v], v))
	return d

def GP(it):
	return [(ch, len(list(g))) for (ch, g) in groupby(it)]

class DLN:

	def __init__(self, val):
		self.val = val
		self.pre = None
		self.next = None
t = N()
for i in range(t):
	n = N()
	a = RLL()
	res = 0
	for x in a:
		res ^= x
	if res == 0:
		ans = 'DRAW'
	else:
		k = 0
		while res:
			res >>= 1
			k += 1
		k -= 1
		c = 0
		for x in a:
			if x & 1 << k:
				c += 1
		c //= 2
		if c & 1:
			if n & 1:
				ans = 'LOSE'
			else:
				ans = 'WIN'
		else:
			ans = 'WIN'
	print(ans)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	N = int(input())
	a = list(map(int, input().split()))
	table = [0] * 31
	for x in a:
		t = 1
		for i in range(31):
			table[i] += x & t > 0
			t <<= 1
	for i in range(N):
		t = 1
		for j in range(31):
			if a[i] & t:
				if table[j] % 2 == 0:
					a[i] -= t
			t <<= 1
	table = [0] * 31
	for x in a:
		t = 1
		for i in range(31):
			table[i] += x & t > 0
			t <<= 1
	win = 0
	for i in range(30, -1, -1):
		if table[i]:
			if table[i] % 4 == 1:
				win = 1
			elif N % 2 == 0:
				win = 1
			else:
				win = -1
			break
	if win == 1:
		print('WIN')
	elif win == 0:
		print('DRAW')
	else:
		print('LOSE')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def print_list(l):
	print(' '.join(map(str, l)))
for _ in range(N()):
	n = N()
	nums = RL()
	digit = [0] * 35
	for a in nums:
		t = 0
		while a:
			if a & 1:
				digit[t] += 1
			a >>= 1
			t += 1
	f = -1
	for d in digit[::-1]:
		if d & 1:
			f = d
			break
	if f == -1:
		print('DRAW')
	elif f >> 1 & 1 == 0:
		print('WIN')
	elif n & 1:
		print('LOSE')
	else:
		print('WIN')


from sys import stdin
tt = int(stdin.readline())
for loop in range(tt):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	now = 0
	for i in range(31, -1, -1):
		now = 0
		tmp = 2 ** i
		for j in a:
			if j & tmp > 0:
				now += 1
		if now % 2 == 1:
			break
	else:
		print('DRAW')
		continue
	rem = n - now
	if now == 1:
		print('WIN')
	elif (now // 2 + 1) % 2 == 0:
		if rem % 2 == 0:
			print('LOSE')
		else:
			print('WIN')
	else:
		print('WIN')


from sys import stdin, stdout

def gamegame(n, a):
	bc = [[0] * 30, [0] * 30]
	for v in a:
		for i in range(30):
			bc[v >> i & 1][i] += 1
	for i in range(29, -1, -1):
		if bc[1][i] % 2 == 1:
			if bc[1][i] % 4 == 3 and bc[0][i] % 2 == 0:
				return 'LOSE'
			else:
				return 'WIN'
	return 'DRAW'
t = int(stdin.readline())
for _ in range(t):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	stdout.write(gamegame(n, a) + '\n')


import sys

def rs():
	return sys.stdin.readline().rstrip()

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

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s)
	sys.stdout.write('\n')

def wi(n):
	sys.stdout.write(str(n))
	sys.stdout.write('\n')

def wia(a, sep=' '):
	sys.stdout.write(sep.join([str(x) for x in a]))
	sys.stdout.write('\n')

def go(n, k):
	if k % 4 == 1:
		return True
	else:
		return n % 2 == 0

def solve(n, a):
	for bit in range(32, -1, -1):
		cnt = 0
		for i in range(n):
			if a[i] & 1 << bit > 0:
				cnt += 1
		if cnt % 2 == 0:
			continue
		if go(n, cnt):
			ws('WIN')
		else:
			ws('LOSE')
		return
	ws('DRAW')

def main():
	for _ in range(ri()):
		n = ri()
		a = ria()
		solve(n, a)
main()


import sys

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

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

def mints():
	return map(int, minp().split())

def solve():
	n = mint()
	x = [0] * 34
	for i in mints():
		j = 0
		while i > 0:
			x[j] += i & 1
			j += 1
			i //= 2
	if n % 2 == 0:
		for i in range(33, -1, -1):
			if x[i] % 2 == 1:
				print('WIN')
				return
	else:
		for i in range(33, -1, -1):
			if x[i] % 4 == 1:
				print('WIN')
				return
			elif x[i] % 4 == 3:
				print('LOSE')
				return
	print('DRAW')
for i in range(mint()):
	solve()


import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
if os.path.exists('out.txt'):
	sys.stdout = open('out.txt', 'w')

def input():
	return sys.stdin.readline()

def mapi(arg=0):
	return map(int if arg == 0 else str, input().split())
for _ in range(int(input())):
	n = int(input())
	a = list(mapi())
	cnt = [0] * 64
	for i in a:
		for j in range(64):
			cnt[j] += i >> j & 1
	draw = 1
	k = 0
	for i in range(63, -1, -1):
		if cnt[i] & 1:
			k = i
			draw = 0
			break
	if draw:
		print('DRAW')
	elif cnt[k] % 4 == 1 or n % 2 == 0:
		print('WIN')
	else:
		print('LOSE')


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf
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
from decimal import Decimal
mod = pow(10, 9) + 7
mod2 = 998244353

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

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

def outa(*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)]
for _ in range(int(data())):
	n = int(data())
	a = l()
	c = C()
	for i in range(n):
		for j in range(32, -1, -1):
			if a[i] & 1 << j:
				c[j] += 1
	answer = 'DRAW'
	for j in range(32, -1, -1):
		if not c[j] & 1:
			continue
		if c[j] % 4 == 3 and (n - c[j]) % 2 == 0:
			answer = 'LOSE'
		else:
			answer = 'WIN'
		break
	out(answer)


from sys import stdin
for case in range(int(stdin.readline())):
	n = int(stdin.readline())
	nums = [int(x) for x in stdin.readline().split()]
	m = max(nums)
	c = 1
	bits = 1
	while c <= m:
		c *= 2
		bits += 1
	end = False
	for bit in range(bits - 1, -1, -1):
		count = 0
		find = 1 << bit
		for x in nums:
			if x & find:
				count += 1
		if count % 4 == 3:
			end = True
			if (n - count) % 2 == 1:
				print('WIN')
			else:
				print('LOSE')
			break
		elif count % 4 == 1:
			end = True
			print('WIN')
			break
	if not end:
		print('DRAW')


from __future__ import division, print_function
MOD = 998244353
mod = 10 ** 9 + 7

def prepare_factorial():
	fact = [1]
	for i in range(1, 100005):
		fact.append(fact[-1] * i % mod)
	ifact = [0] * 100005
	ifact[100004] = pow(fact[100004], mod - 2, mod)
	for i in range(100004, 0, -1):
		ifact[i - 1] = i * ifact[i] % mod
	return (fact, ifact)
import sys
from bisect import bisect_left, bisect_right, insort
from math import floor, ceil, sqrt, degrees, atan, pi, log, sin, radians
from heapq import heappop, heapify, heappush
from collections import Counter, defaultdict, deque

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, fact, ifact):
	t = fact[n] * (ifact[r] * ifact[n - r]) % mod % mod
	return t

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

def array():
	return list(map(int, sys.stdin.readline().strip().split()))

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

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	return x * y // GCD(x, y)

def get_xor(n):
	return [n, 1, n + 1, 0][n % 4]

def fast_expo(a, b):
	res = 1
	while b:
		if b & 1:
			res = res * a
			res %= MOD
			b -= 1
		else:
			a = a * a
			a %= MOD
			b >>= 1
	res %= MOD
	return res

def get_n(P):
	ans = (-1 + sqrt(1 + 8 * P)) // 2
	return ans

def solve():
	n = int(input())
	out1 = [0] * 31
	out0 = [0] * 31
	a = array()
	for i in range(31):
		for j in a:
			if j & 1 << i:
				out1[i] += 1
			else:
				out0[i] += 1
	out1 = out1[::-1]
	out0 = out0[::-1]
	for i in range(31):
		if out1[i] % 4 == 1:
			print('WIN')
			return
		if out1[i] % 2 != 0 and out0[i] % 2 != 0:
			print('WIN')
			return
		if out1[i] % 2 != 0 and out0[i] % 2 == 0:
			print('LOSE')
			return
	print('DRAW')
	return

def main():
	T = int(input())
	while T:
		solve()
		T -= 1
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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')
main()


import sys

def solve(significant, filler):
	if filler % 2 == 0:
		return significant % 4 == 1
	return True

def i():
	return sys.stdin.readline()[:-1]
for _ in range(int(i())):
	digits = [0] * 30
	n = int(i())
	nums = map(int, i().split())
	for num in nums:
		binNum = bin(num)
		binNum = binNum[2:]
		binNum = binNum[::-1]
		for (index, char) in enumerate(binNum):
			if char == '1':
				digits[index] += 1
	digits = digits[::-1]
	msb = 0
	draw = False
	for x in range(30):
		if digits[x] % 2 != 0:
			msb = digits[x]
			break
	else:
		print('DRAW')
		draw = True
	if not draw:
		if solve(msb, n - msb):
			print('WIN')
		else:
			print('LOSE')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

def lcm(a, b):
	return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
	n = int(input())
	a = list(map(int, input().split()))
	bits = [[0, 0] for __ in range(64)]
	for i in a:
		b = binary(i, 64)[::-1]
		for j in range(64):
			bits[j][int(b[j])] += 1
	ans = 'DRAW'
	for i in range(63, -1, -1):
		if not bits[i][1] % 2:
			continue
		if (bits[i][1] - 1) % 4 == 0 or (bits[i][1] + bits[i][0] % 2) % 2 == 0:
			ans = 'WIN'
			break
		else:
			ans = 'LOSE'
			break
	print(ans)


import os, sys
from io import BytesIO, IOBase

def highest_bit(x):
	y = 0
	while x:
		y = x
		x &= x - 1
	return y

def count_highest_bit(arr, bit):
	cou = ans = 0
	while bit:
		bit //= 2
		cou += 1
	for x in arr:
		for _ in range(cou - 1):
			x //= 2
		if x % 2:
			ans += 1
	return ans

def main():
	for _ in range(int(input())):
		n = int(input())
		a = list(map(int, input().split()))
		xor = 0
		for i in a:
			xor ^= i
		if not xor:
			print('DRAW')
		else:
			bi = highest_bit(xor)
			freq = count_highest_bit(a, bi)
			if not n % 2:
				print('WIN')
			elif not freq // 2 % 2:
				print('WIN')
			else:
				print('LOSE')
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	arr = [int(i) for i in sys.stdin.readline().split()]
	highest_bit_with_odd_set = -1
	num_set = 0
	cur = 0
	while 1 << cur < 10 ** 9:
		check = 1 << cur
		num_set_cur = 0
		for a in arr:
			if a & check != 0:
				num_set_cur += 1
		if num_set_cur % 2 != 0:
			highest_bit_with_odd_set = cur
			num_set = num_set_cur
		cur += 1
	if highest_bit_with_odd_set == -1:
		print('DRAW')
	elif num_set % 4 == 1 or (num_set % 4 == 3 and (n - num_set) % 2 == 1):
		print('WIN')
	else:
		print('LOSE')


import sys
input = sys.stdin.readline
T = int(input())
for t in range(T):
	N = int(input())
	A = [int(_) for _ in input().split()]
	A = [format(el, '#040b')[2:] for el in A]
	end = False
	for i in range(len(A[0])):
		cnt0 = 0
		cnt1 = 0
		for el in A:
			if el[i] == '0':
				cnt0 += 1
			else:
				cnt1 += 1
		if cnt1 == 1:
			print('WIN')
			end = True
			break
		if not cnt1 % 2:
			continue
		if cnt1 % 4 == 1:
			print('WIN')
			end = True
			break
		else:
			assert cnt1 % 4 == 3
			if cnt0 % 2:
				print('WIN')
			else:
				print('LOSE')
			end = True
			break
	if not end:
		print('DRAW')


from sys import stdin
t = int(stdin.readline().strip())
for _ in range(t):
	n = int(stdin.readline().strip())
	A = list(map(int, stdin.readline().strip().split(' ')))
	bit_counts = [0] * 32
	for a in A:
		for i in range(32):
			if a >> i & 1:
				bit_counts[i] += 1
	outcome = 'DRAW'
	for i in range(31, -1, -1):
		if bit_counts[i] % 4 == 1:
			outcome = 'WIN'
			break
		elif bit_counts[i] % 4 == 3:
			if n % 2 == 0:
				outcome = 'WIN'
			else:
				outcome = 'LOSE'
			break
	print(outcome)


for i in range(int(input())):
	n = int(input())
	l = map(int, input().split())
	lm = []
	mmm = 1
	for j in l:
		new = list(reversed(list(map(int, list(bin(j))[2:]))))
		mmm = max(mmm, len(new))
		lm.append(new)
	c = [0 for i in range(mmm)]
	for j in lm:
		for k in range(len(j)):
			c[k] += j[k]
	res = 'DRAW'
	for j in range(len(c) - 1, -1, -1):
		if c[j] % 2 == 1:
			if c[j] % 4 == 1:
				res = 'WIN'
				break
			elif (n - c[j]) % 2 == 0:
				res = 'LOSE'
				break
			else:
				res = 'WIN'
				break
	print(res)


import sys
inpy = [int(x) for x in sys.stdin.read().split()]
t = inpy[0]
index = 1
for _ in range(t):
	n = inpy[index]
	num = inpy[index + 1:index + 1 + n]
	index += 1 + n
	memo = [0] * 32
	for i in range(32):
		x = 1 << i
		for j in num:
			if j & x:
				memo[i] += 1
	res = 0
	for i in reversed(memo):
		if i % 2 == 0:
			continue
		elif i % 4 == 1 or (i % 4 == 3 and n % 2 == 0):
			print('WIN')
			res = 1
			break
		elif i % 4 == 3:
			print('LOSE')
			res = 3
			break
	if res == 0:
		print('DRAW')


d = {1: 'WIN', 0: 'LOSE', -1: 'DRAW'}
T = int(input())
for _ in range(T):
	n = int(input())
	a = map(int, input().split())
	f = [0] * 30
	for val in a:
		for b in range(30):
			if val & 1 << b:
				f[b] += 1
	ans = -1
	for x in range(29, -1, -1):
		if f[x] & 1:
			ans = 0 if f[x] % 4 == 3 and (n - f[x]) % 2 == 0 else 1
			break
	print(d[ans])


from math import inf as inf
from math import *
from collections import *
import sys
import os
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [0] * 31
	fl = 'DRAW'
	for i in a:
		z = bin(i)[2:]
		z = z.zfill(31)
		for j in range(31):
			if z[j] == '1':
				b[j] += 1
	for i in b:
		if i % 2 == 0:
			continue
		if i % 4 == 3 and (n - i) % 2 == 0:
			fl = 'LOSE'
		else:
			fl = 'WIN'
		break
	print(fl)


from collections import defaultdict
w = 'WIN'
d = 'DRAW'
l = 'LOSE'
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	for i in range(30, -1, -1):
		c = 2 ** i
		s1 = 0
		s0 = 0
		for j in arr:
			if j & 2 ** i != 0:
				s1 += 1
			else:
				s0 += 1
		if s1 % 2 == 0:
			ans = d
			continue
		elif s1 % 4 == 3 and s0 % 2 == 0:
			ans = l
			break
		else:
			ans = w
			break
	print(ans)


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	win = 0
	for i in range(31)[::-1]:
		c1 = 0
		c0 = 0
		for j in range(n):
			if a[j] >> i & 1:
				c1 += 1
			else:
				c0 += 1
		if c1 % 2 == 0:
			continue
		if c1 % 4 == 3 and c0 % 2 == 0:
			win = -1
			break
		else:
			win = 1
			break
	if win == 1:
		print('WIN')
	elif win == 0:
		print('DRAW')
	else:
		print('LOSE')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)

def toord(c):
	return ord(c) - ord('a')

def lcm(a, b):
	return a * b // lcm(a, b)
mod = 998244353
INF = float('inf')
from math import factorial, sqrt, ceil, floor, gcd
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

def main():
	for _ in range(N()):
		n = N()
		arr = RLL()
		rec = [0] * 30
		for i in arr:
			for j in range(30):
				rec[j] += i >> j & 1
		for i in range(29, -1, -1):
			if rec[i] & 1:
				if (n - rec[i]) % 2 == 0 and rec[i] % 4 == 3:
					print('LOSE')
				else:
					print('WIN')
				break
		else:
			print('DRAW')
main()


import sys, math
import io, os
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter

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

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write('\n'.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
from fractions import Fraction
INF = float('inf')
mod = int(1000000000.0) + 7
for t in range(int(data())):
	n = int(data())
	a = sorted(mdata(), reverse=True)
	(x, y) = (0, 0)
	s = 0
	l = [0] * 32
	for i in range(n):
		s = s ^ a[i]
		for j in range(32):
			if 1 << j & a[i]:
				l[j] += 1
	if s == 0:
		out('DRAW')
		continue
	if n % 2 == 0:
		out('WIN')
	else:
		for i in range(31, -1, -1):
			if l[i] % 2 != 0:
				if l[i] % 4 == 1:
					out('WIN')
				else:
					out('LOSE')
				break


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	cnts = [0] * 40
	for i in range(n):
		for j in range(40):
			if a[i] >> j & 1:
				cnts[j] += 1
	for cnt in cnts[::-1]:
		cnt0 = n - cnt
		cnt1 = cnt
		if cnt1 % 2 == 0:
			continue
		if cnt1 % 4 == 1:
			print('WIN')
			break
		if cnt1 % 4 == 3 and cnt0 % 2 == 1:
			print('WIN')
			break
		if cnt1 % 4 == 3 and cnt0 % 2 == 0:
			print('LOSE')
			break
	else:
		print('DRAW')


t = int(input())
import math
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().strip().split()))[:n]
	a = max(arr)
	if a == 0:
		k = 0
	else:
		k = int(math.log2(a)) + 1
	flag = 0
	for i in range(k, -1, -1):
		x = 0
		y = 0
		f = 1 << i
		for num in arr:
			if num & f:
				x += 1
			else:
				y += 1
		if x % 2 != 0:
			if x % 4 == 3 and y % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			flag = 1
			break
	if flag == 0:
		print('DRAW')


import sys

def input():
	return sys.stdin.readline().rstrip()

def input_split():
	return [int(i) for i in input().split()]
testCases = int(input())
answers = []

def fill(a, counts):
	ctr = 0
	while a > 0:
		counts[ctr] += a % 2
		a = a // 2
		ctr += 1
for _ in range(testCases):
	n = int(input())
	arr = input_split()
	counts = [0 for i in range(50)]
	for a in arr:
		fill(a, counts)
	s = sum([c % 2 for c in counts])
	if s > 0:
		counts.reverse()
		for c in counts:
			if c % 2 == 1:
				first_odd = c
				break
		if n % 2 == 1 and first_odd % 4 == 3:
			ans = 'LOSE'
		else:
			ans = 'WIN'
	else:
		ans = 'DRAW'
	answers.append(ans)
print(*answers, sep='\n')


t = int(input())
for i in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	c = [0 for j in range(31)]
	msb = 0
	for j in l:
		a = bin(j).lstrip('0b')
		msb = max(msb, len(a) - 1)
		for k in range(len(a) - 1, -1, -1):
			if a[k] == '1':
				c[len(a) - 1 - k] += 1
	ans = 'DRAW'
	for j in range(msb, -1, -1):
		if c[j] % 2 == 0:
			continue
		else:
			if c[j] % 4 == 3 and (n - c[j]) % 2 == 0:
				ans = 'LOSE'
			else:
				ans = 'WIN'
			break
	print(ans)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = 'DRAW'
	for i in range(32, -1, -1):
		(x, y) = (0, 0)
		for num in arr:
			if num & 1 << i == 0:
				y += 1
			else:
				x += 1
		if x % 2 == 1:
			if x % 4 == 3 and y % 2 == 0:
				ans = 'LOSE'
				break
			else:
				ans = 'WIN'
				break
	print(ans)


for _ in range(int(input())):
	n = int(input())
	a = [int(o) for o in input().split()]
	ones = [0] * 35
	zeros = [0] * 35
	for i in a:
		ba = bin(i)[2:][::-1]
		j = -1
		for k in ba:
			if k == '1':
				ones[j] += 1
			else:
				zeros[j] += 1
			j -= 1
	res = 'DRAW'
	for i in range(35):
		if ones[i] % 2 != 0:
			if ones[i] % 4 == 3 and (n - ones[i]) % 2 == 0:
				res = 'LOSE'
			else:
				res = 'WIN'
			break
	print(res)


import sys
input = sys.stdin.buffer.readline
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [int(x) for x in input().split()]
	zeroBitCnt = [0 for _ in range(30)]
	oneBitCnt = [0 for _ in range(30)]
	for x in arr:
		for i in range(30):
			if x & 1 << i > 0:
				oneBitCnt[i] += 1
			else:
				zeroBitCnt[i] += 1
	ok = False
	for i in range(29, -1, -1):
		if oneBitCnt[i] % 2 == 0:
			continue
		else:
			if oneBitCnt[i] % 4 == 3 and zeroBitCnt[i] % 2 == 0:
				print('LOSE')
			else:
				print('WIN')
			ok = True
			break
	if ok == False:
		print('DRAW')


t = input()
t = int(t)

def solve(n, arr):
	a_max = max(arr)
	k = len(bin(a_max)) - 2
	while k > 0:
		mask = 2 ** (k - 1)
		n_1 = 0
		n_0 = 0
		for x in arr:
			if x & mask == mask:
				n_1 += 1
			else:
				n_0 += 1
		if n_1 % 4 == 3 and n_0 % 2 == 0:
			print('LOSE')
			return
		elif n_1 % 2 == 1:
			print('WIN')
			return
		k -= 1
	print('DRAW')
	return
for i in range(t):
	n = input()
	n = int(n)
	arr = list(map(int, input().split()))
	solve(n, arr)


def calc(nums):
	for i in range(30, -1, -1):
		count = 0
		for num in nums:
			if num & 1 << i > 0:
				count += 1
		if count % 2 != 0:
			return count
	return -1
t = int(input())
for _ in range(t):
	n = int(input())
	nums = list(map(int, input().split()))
	flag = calc(nums)
	if flag == -1:
		print('DRAW')
	elif (flag - 1) // 2 % 2 != 0 and n % 2 != 0:
		print('LOSE')
	else:
		print('WIN')


d = {1: 'WIN', 0: 'LOSE', -1: 'DRAW'}
ans = []
for _ in range(int(input())):
	n = int(input())
	u = list(map(int, input().split()))
	f = [0] * 30
	for x in u:
		for b in range(30):
			if x >> b & 1:
				f[b] += 1
	ansi = -1
	for x in range(29, -1, -1):
		if f[x] % 2 == 1:
			if f[x] % 4 == 3 and (n - f[x]) % 2 == 0:
				ansi = 0
			else:
				ansi = 1
			break
	ans.append(d[ansi])
print('\n'.join(ans))


a = int(input())
for y in range(a):
	d = int(input())
	z = list(map(int, input().split()))
	for i in range(len(z)):
		z[i] = bin(z[i])
		z[i] = z[i][2:]
	maxa = 0
	for i in range(len(z)):
		if z[i][0] == '1':
			maxa = max(maxa, len(z[i]))
	for i in range(len(z)):
		if len(z[i]) < maxa:
			z[i] = '0' * (maxa - len(z[i])) + z[i]
	flag = 0
	while len(z[0]):
		good = 0
		bad = 0
		for i in range(len(z)):
			if z[i][0] == '1':
				good += 1
			else:
				bad += 1
		if good % 2 == 1 and bad % 2 == 1:
			print('WIN')
			flag = 1
			break
		elif good % 2 == 0:
			maxa = 0
			if len(z[0]) == 1:
				break
			for i in range(len(z)):
				z[i] = z[i][1:]
			continue
		elif good % 4 == 3 and bad % 2 == 0:
			print('LOSE')
			flag = 1
			break
		else:
			flag = 1
			print('WIN')
			break
	if flag == 1:
		continue
	else:
		print('DRAW')