#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using dd = double;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vdd = vector<dd>;
using vpll = vector<pll>;
using vtll = vector<tll>;
using vvll = vector<vll>;
using vvdd = vector<vdd>;
using vvpll = vector<vpll>;
using vvtll = vector<vtll>;
using vvvll = vector<vvll>;
using vvvdd = vector<vvdd>;
using vvvpll = vector<vvpll>;
using vvvtll = vector<vvtll>;
using vvvvll = vector<vvvll>;
using vvvvdd = vector<vvvdd>;
using vvvvpll = vector<vvvpll>;
using vvvvtll = vector<vvvtll>;
constexpr ll INF = 1LL << 60;
constexpr dd EPS = 1e-11;
constexpr dd PI = 3.1415926535897932;
struct Fast {
  Fast() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
  }
} fast;
template <class T>
inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline T MaxE(vector<T> &v, ll S, ll E) {
  T m = v[S];
  for (ll i = (S); i <= (E); i++) chmax(m, v[i]);
  return m;
}
template <class T>
inline T MinE(vector<T> &v, ll S, ll E) {
  T m = v[S];
  for (ll i = (S); i <= (E); i++) chmin(m, v[i]);
  return m;
}
template <class T>
inline T MaxE(vector<T> &v, ll N) {
  return MaxE(v, 0, N - 1);
}
template <class T>
inline T MinE(vector<T> &v, ll N) {
  return MinE(v, 0, N - 1);
}
template <class T>
inline T MaxE(vector<T> &v) {
  return MaxE(v, (ll)v.size());
}
template <class T>
inline T MinE(vector<T> &v) {
  return MinE(v, (ll)v.size());
}
template <class T>
inline ll MaxI(vector<T> &v, ll S, ll E) {
  ll m = S;
  for (ll i = (S); i <= (E); i++) {
    if (v[i] > v[m]) m = i;
  }
  return m;
}
template <class T>
inline ll MinI(vector<T> &v, ll S, ll E) {
  ll m = S;
  for (ll i = (S); i <= (E); i++) {
    if (v[i] < v[m]) m = i;
  }
  return m;
}
template <class T>
inline ll MaxI(vector<T> &v, ll N) {
  return MaxI(v, 0, N - 1);
}
template <class T>
inline ll MinI(vector<T> &v, ll N) {
  return MinI(v, 0, N - 1);
}
template <class T>
inline ll MaxI(vector<T> &v) {
  return MaxI(v, (ll)v.size());
}
template <class T>
inline ll MinI(vector<T> &v) {
  return MinI(v, (ll)v.size());
}
template <class T>
inline T Sum(vector<T> &v, ll S, ll E) {
  T s = v[S];
  for (ll i = (S + 1); i <= (E); i++) s += v[i];
  return s;
}
template <class T>
inline T Sum(vector<T> &v, ll N) {
  return Sum(v, 0, N - 1);
}
template <class T>
inline T Sum(vector<T> &v) {
  return Sum(v, v.size());
}
template <class T>
inline ll sz(T &v) {
  return (ll)v.size();
}
template <class T>
inline T POW(T a, ll n) {
  T r = 1;
  for (; n > 0; n >>= 1, a *= a) {
    if (n & 1) r *= a;
  }
  return r;
}
inline ll POW(int a, ll n) { return POW((ll)a, n); }
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
ll Gcd(ll a, ll b) { return (b == 0) ? a : Gcd(b, a % b); }
ll Lcm(ll a, ll b) { return a * b / Gcd(a, b); }
inline ll MSB(ll a) {
  for (ll o = 63, x = -1;;) {
    ll m = (o + x) / 2;
    if (a < (1LL << m))
      o = m;
    else
      x = m;
    if (o - x == 1) return x;
  }
}
inline ll Upper2N(ll s) { return 1LL << MSB(s) << 1; }
inline vll Bit2Idx(ll m) {
  vll v;
  for (ll i = 0; m; m >>= 1, i++)
    if (m & 1) v.push_back(i);
  return move(v);
}
inline ll BitNum(ll m) {
  for (ll c = 0;; m >>= 1) {
    c += m & 1;
    if (!m) return c;
  }
}
inline ll Bit(ll s, ll i) { return (s >> i) & 1; }
[[nodiscard]] inline ll BitOn(ll s, ll i) { return s | (1LL << i); }
[[nodiscard]] inline ll BitOff(ll s, ll i) { return s & ~(1LL << i); }
[[nodiscard]] inline ll BitCut(ll s, ll i) { return s & (1LL << ++i) - 1; }
inline vll str2num(string &s, ll N) {
  vll v(N);
  for (ll i = (0); i <= ((N)-1); i++) v[i] = (ll)(s[i] - '0');
  return move(v);
}
inline vll ALP2num(string &s, ll N) {
  vll v(N);
  for (ll i = (0); i <= ((N)-1); i++) v[i] = (ll)(s[i] - 'A');
  return move(v);
}
inline vll alp2num(string &s, ll N) {
  vll v(N);
  for (ll i = (0); i <= ((N)-1); i++) v[i] = (ll)(s[i] - 'a');
  return move(v);
}
template <class T>
inline ll FloorIdx(vector<T> &v, T x) {
  return upper_bound((v).begin(), (v).end(), x) - v.begin() - 1;
}
template <class T>
inline ll CeilIdx(vector<T> &v, T x) {
  return lower_bound((v).begin(), (v).end(), x) - v.begin();
}
template <class T>
inline ll UnderNumOf(vector<T> &v, T x) {
  return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T, class Pr>
inline ll UnderNumOf(vector<T> &v, T x, Pr pred) {
  return upper_bound(v.begin(), v.end(), x, pred) - v.begin();
}
template <class T>
inline ll OverNumOf(vector<T> &v, T x) {
  return (ll)v.size() - (lower_bound(v.begin(), v.end(), x) - v.begin());
}
template <class T, class Pr>
inline ll OverNumOf(vector<T> &v, T x, Pr pred) {
  return (ll)v.size() - (lower_bound(v.begin(), v.end(), x, pred) - v.begin());
}
template <class T = ll>
inline vector<T> cinv(ll N) {
  vector<T> v(N);
  for (ll i = (0); i <= ((N)-1); i++) cin >> v[i];
  return move(v);
}
template <class T = ll, class S = ll>
inline vector<pair<T, S>> cinv2(ll N) {
  vector<pair<T, S>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> v[i].first >> v[i].second;
  }
  return move(v);
}
template <class T = ll, class S = ll, class R = ll>
inline vector<tuple<T, S, R>> cinv3(ll N) {
  vector<tuple<T, S, R>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]);
  }
  return move(v);
}
template <class T = ll, class S = ll, class R = ll, class Q = ll>
inline vector<tuple<T, S, R, Q>> cinv4(ll N) {
  vector<tuple<T, S, R, Q>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]) >> get<3>(v[i]);
  }
  return move(v);
}
template <class T = ll>
inline vector<vector<T>> cinvv(ll N, ll M) {
  vector<vector<T>> vv(N);
  for (ll i = (0); i <= ((N)-1); i++) vv[i] = cinv(M);
  return move(vv);
}
template <class T>
inline void coutv(vector<T> &v, string d = " ") {
  ll N = (ll)v.size();
  for (ll i = (0); i <= ((N)-1); i++) {
    cout << v[i] << ((i == N - 1) ? "" : d);
  }
  cout << '\n';
}
template <class T>
inline void coutv(deque<T> &v, string d = " ") {
  ll N = (ll)v.size();
  for (ll i = (0); i <= ((N)-1); i++) {
    cout << v[i] << ((i == N - 1) ? "" : d);
  }
  cout << '\n';
}
template <class T>
void bye(T a) {
  cout << a << '\n';
  exit(0);
}
template <class T>
void Dump(vector<T> &v) {}
template <class T>
void Dump(vector<vector<T>> &v) {}
template <class T>
void Dump(vector<vector<vector<T>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<T>>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<vector<T>>>>> &v) {}
template <ll MOD>
struct mll_ {
  ll val;
  mll_(ll v = 0) : val(v % MOD) {
    if (val < 0) val += MOD;
  }
  mll_ operator-() const { return -val; }
  mll_ operator+(const mll_ &b) const { return val + b.val; }
  mll_ operator-(const mll_ &b) const { return val - b.val; }
  mll_ operator*(const mll_ &b) const { return val * b.val; }
  mll_ operator/(const mll_ &b) const { return mll_(*this) /= b; }
  mll_ operator+(ll b) const { return *this + mll_(b); }
  mll_ operator-(ll b) const { return *this - mll_(b); }
  mll_ operator*(ll b) const { return *this * mll_(b); }
  friend mll_ operator+(ll a, const mll_ &b) { return b + a; }
  friend mll_ operator-(ll a, const mll_ &b) { return -b + a; }
  friend mll_ operator*(ll a, const mll_ &b) { return b * a; }
  friend mll_ operator/(ll a, const mll_ &b) { return mll_(a) / b; }
  mll_ &operator+=(const mll_ &b) {
    val = (val + b.val) % MOD;
    return *this;
  }
  mll_ &operator-=(const mll_ &b) {
    val = (val + MOD - b.val) % MOD;
    return *this;
  }
  mll_ &operator*=(const mll_ &b) {
    val = (val * b.val) % MOD;
    return *this;
  }
  mll_ &operator/=(const mll_ &b) {
    ll c = b.val, d = MOD, u = 1, v = 0;
    while (d) {
      ll t = c / d;
      c -= t * d;
      swap(c, d);
      u -= t * v;
      swap(u, v);
    }
    val = val * u % MOD;
    if (val < 0) val += MOD;
    return *this;
  }
  mll_ &operator+=(ll b) { return *this += mll_(b); }
  mll_ &operator-=(ll b) { return *this -= mll_(b); }
  mll_ &operator*=(ll b) { return *this *= mll_(b); }
  mll_ &operator/=(ll b) { return *this /= mll_(b); }
  bool operator==(const mll_ &b) { return val == b.val; }
  bool operator!=(const mll_ &b) { return val != b.val; }
  bool operator==(ll b) { return *this == mll_(b); }
  bool operator!=(ll b) { return *this != mll_(b); }
  friend bool operator==(ll a, const mll_ &b) { return mll_(a) == b.val; }
  friend bool operator!=(ll a, const mll_ &b) { return mll_(a) != b.val; }
  friend ostream &operator<<(ostream &os, const mll_ &a) { return os << a.val; }
  friend istream &operator>>(istream &is, mll_ &a) { return is >> a.val; }
  static mll_ Combination(ll a, ll b) {
    chmin(b, a - b);
    if (b < 0) return mll_(0);
    mll_ c = 1;
    for (ll i = (0); i <= ((b)-1); i++) c *= a - i;
    for (ll i = (0); i <= ((b)-1); i++) c /= i + 1;
    return c;
  }
};
using mll = mll_<1000000007LL>;
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
using vvvvvmll = std::vector<vvvvmll>;
void solve() {
  ll n;
  cin >> n;
  vector<ll> a = cinv<ll>(n);
  ll all = 0;
  for (auto &&e : a) all ^= e;
  if (all == 0) {
    cout << "DRAW" << '\n';
    return;
  }
  ll ms = MSB(all);
  ll x = 0;
  ll y = 0;
  for (auto &&e : a) {
    if (Bit(e, ms) == 1)
      x++;
    else
      y++;
  }
  if (x % 4 == 1) {
    cout << "WIN" << '\n';
    return;
  }
  if (y % 2 == 0) {
    cout << "LOSE" << '\n';
    return;
  }
  cout << "WIN" << '\n';
  return;
}
int main() {
  ll t;
  cin >> t;
  for (ll i = (0); i <= (t - 1); i++) {
    solve();
  }
  return 0;
}

### Prompt

Create a solution in cpp for the following problem:

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 ⊕ y. Here ⊕ denotes [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).

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 ≤ t ≤ 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 ≤ n ≤ 10^5) — the length of a.

The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 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 ⊕ 2 = 3 and score for other player is 2 so Koa wins.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using dd = double;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vdd = vector<dd>;
using vpll = vector<pll>;
using vtll = vector<tll>;
using vvll = vector<vll>;
using vvdd = vector<vdd>;
using vvpll = vector<vpll>;
using vvtll = vector<vtll>;
using vvvll = vector<vvll>;
using vvvdd = vector<vvdd>;
using vvvpll = vector<vvpll>;
using vvvtll = vector<vvtll>;
using vvvvll = vector<vvvll>;
using vvvvdd = vector<vvvdd>;
using vvvvpll = vector<vvvpll>;
using vvvvtll = vector<vvvtll>;
constexpr ll INF = 1LL << 60;
constexpr dd EPS = 1e-11;
constexpr dd PI = 3.1415926535897932;
struct Fast {
  Fast() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
  }
} fast;
template <class T>
inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline T MaxE(vector<T> &v, ll S, ll E) {
  T m = v[S];
  for (ll i = (S); i <= (E); i++) chmax(m, v[i]);
  return m;
}
template <class T>
inline T MinE(vector<T> &v, ll S, ll E) {
  T m = v[S];
  for (ll i = (S); i <= (E); i++) chmin(m, v[i]);
  return m;
}
template <class T>
inline T MaxE(vector<T> &v, ll N) {
  return MaxE(v, 0, N - 1);
}
template <class T>
inline T MinE(vector<T> &v, ll N) {
  return MinE(v, 0, N - 1);
}
template <class T>
inline T MaxE(vector<T> &v) {
  return MaxE(v, (ll)v.size());
}
template <class T>
inline T MinE(vector<T> &v) {
  return MinE(v, (ll)v.size());
}
template <class T>
inline ll MaxI(vector<T> &v, ll S, ll E) {
  ll m = S;
  for (ll i = (S); i <= (E); i++) {
    if (v[i] > v[m]) m = i;
  }
  return m;
}
template <class T>
inline ll MinI(vector<T> &v, ll S, ll E) {
  ll m = S;
  for (ll i = (S); i <= (E); i++) {
    if (v[i] < v[m]) m = i;
  }
  return m;
}
template <class T>
inline ll MaxI(vector<T> &v, ll N) {
  return MaxI(v, 0, N - 1);
}
template <class T>
inline ll MinI(vector<T> &v, ll N) {
  return MinI(v, 0, N - 1);
}
template <class T>
inline ll MaxI(vector<T> &v) {
  return MaxI(v, (ll)v.size());
}
template <class T>
inline ll MinI(vector<T> &v) {
  return MinI(v, (ll)v.size());
}
template <class T>
inline T Sum(vector<T> &v, ll S, ll E) {
  T s = v[S];
  for (ll i = (S + 1); i <= (E); i++) s += v[i];
  return s;
}
template <class T>
inline T Sum(vector<T> &v, ll N) {
  return Sum(v, 0, N - 1);
}
template <class T>
inline T Sum(vector<T> &v) {
  return Sum(v, v.size());
}
template <class T>
inline ll sz(T &v) {
  return (ll)v.size();
}
template <class T>
inline T POW(T a, ll n) {
  T r = 1;
  for (; n > 0; n >>= 1, a *= a) {
    if (n & 1) r *= a;
  }
  return r;
}
inline ll POW(int a, ll n) { return POW((ll)a, n); }
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
ll Gcd(ll a, ll b) { return (b == 0) ? a : Gcd(b, a % b); }
ll Lcm(ll a, ll b) { return a * b / Gcd(a, b); }
inline ll MSB(ll a) {
  for (ll o = 63, x = -1;;) {
    ll m = (o + x) / 2;
    if (a < (1LL << m))
      o = m;
    else
      x = m;
    if (o - x == 1) return x;
  }
}
inline ll Upper2N(ll s) { return 1LL << MSB(s) << 1; }
inline vll Bit2Idx(ll m) {
  vll v;
  for (ll i = 0; m; m >>= 1, i++)
    if (m & 1) v.push_back(i);
  return move(v);
}
inline ll BitNum(ll m) {
  for (ll c = 0;; m >>= 1) {
    c += m & 1;
    if (!m) return c;
  }
}
inline ll Bit(ll s, ll i) { return (s >> i) & 1; }
[[nodiscard]] inline ll BitOn(ll s, ll i) { return s | (1LL << i); }
[[nodiscard]] inline ll BitOff(ll s, ll i) { return s & ~(1LL << i); }
[[nodiscard]] inline ll BitCut(ll s, ll i) { return s & (1LL << ++i) - 1; }
inline vll str2num(string &s, ll N) {
  vll v(N);
  for (ll i = (0); i <= ((N)-1); i++) v[i] = (ll)(s[i] - '0');
  return move(v);
}
inline vll ALP2num(string &s, ll N) {
  vll v(N);
  for (ll i = (0); i <= ((N)-1); i++) v[i] = (ll)(s[i] - 'A');
  return move(v);
}
inline vll alp2num(string &s, ll N) {
  vll v(N);
  for (ll i = (0); i <= ((N)-1); i++) v[i] = (ll)(s[i] - 'a');
  return move(v);
}
template <class T>
inline ll FloorIdx(vector<T> &v, T x) {
  return upper_bound((v).begin(), (v).end(), x) - v.begin() - 1;
}
template <class T>
inline ll CeilIdx(vector<T> &v, T x) {
  return lower_bound((v).begin(), (v).end(), x) - v.begin();
}
template <class T>
inline ll UnderNumOf(vector<T> &v, T x) {
  return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T, class Pr>
inline ll UnderNumOf(vector<T> &v, T x, Pr pred) {
  return upper_bound(v.begin(), v.end(), x, pred) - v.begin();
}
template <class T>
inline ll OverNumOf(vector<T> &v, T x) {
  return (ll)v.size() - (lower_bound(v.begin(), v.end(), x) - v.begin());
}
template <class T, class Pr>
inline ll OverNumOf(vector<T> &v, T x, Pr pred) {
  return (ll)v.size() - (lower_bound(v.begin(), v.end(), x, pred) - v.begin());
}
template <class T = ll>
inline vector<T> cinv(ll N) {
  vector<T> v(N);
  for (ll i = (0); i <= ((N)-1); i++) cin >> v[i];
  return move(v);
}
template <class T = ll, class S = ll>
inline vector<pair<T, S>> cinv2(ll N) {
  vector<pair<T, S>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> v[i].first >> v[i].second;
  }
  return move(v);
}
template <class T = ll, class S = ll, class R = ll>
inline vector<tuple<T, S, R>> cinv3(ll N) {
  vector<tuple<T, S, R>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]);
  }
  return move(v);
}
template <class T = ll, class S = ll, class R = ll, class Q = ll>
inline vector<tuple<T, S, R, Q>> cinv4(ll N) {
  vector<tuple<T, S, R, Q>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]) >> get<3>(v[i]);
  }
  return move(v);
}
template <class T = ll>
inline vector<vector<T>> cinvv(ll N, ll M) {
  vector<vector<T>> vv(N);
  for (ll i = (0); i <= ((N)-1); i++) vv[i] = cinv(M);
  return move(vv);
}
template <class T>
inline void coutv(vector<T> &v, string d = " ") {
  ll N = (ll)v.size();
  for (ll i = (0); i <= ((N)-1); i++) {
    cout << v[i] << ((i == N - 1) ? "" : d);
  }
  cout << '\n';
}
template <class T>
inline void coutv(deque<T> &v, string d = " ") {
  ll N = (ll)v.size();
  for (ll i = (0); i <= ((N)-1); i++) {
    cout << v[i] << ((i == N - 1) ? "" : d);
  }
  cout << '\n';
}
template <class T>
void bye(T a) {
  cout << a << '\n';
  exit(0);
}
template <class T>
void Dump(vector<T> &v) {}
template <class T>
void Dump(vector<vector<T>> &v) {}
template <class T>
void Dump(vector<vector<vector<T>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<T>>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<vector<T>>>>> &v) {}
template <ll MOD>
struct mll_ {
  ll val;
  mll_(ll v = 0) : val(v % MOD) {
    if (val < 0) val += MOD;
  }
  mll_ operator-() const { return -val; }
  mll_ operator+(const mll_ &b) const { return val + b.val; }
  mll_ operator-(const mll_ &b) const { return val - b.val; }
  mll_ operator*(const mll_ &b) const { return val * b.val; }
  mll_ operator/(const mll_ &b) const { return mll_(*this) /= b; }
  mll_ operator+(ll b) const { return *this + mll_(b); }
  mll_ operator-(ll b) const { return *this - mll_(b); }
  mll_ operator*(ll b) const { return *this * mll_(b); }
  friend mll_ operator+(ll a, const mll_ &b) { return b + a; }
  friend mll_ operator-(ll a, const mll_ &b) { return -b + a; }
  friend mll_ operator*(ll a, const mll_ &b) { return b * a; }
  friend mll_ operator/(ll a, const mll_ &b) { return mll_(a) / b; }
  mll_ &operator+=(const mll_ &b) {
    val = (val + b.val) % MOD;
    return *this;
  }
  mll_ &operator-=(const mll_ &b) {
    val = (val + MOD - b.val) % MOD;
    return *this;
  }
  mll_ &operator*=(const mll_ &b) {
    val = (val * b.val) % MOD;
    return *this;
  }
  mll_ &operator/=(const mll_ &b) {
    ll c = b.val, d = MOD, u = 1, v = 0;
    while (d) {
      ll t = c / d;
      c -= t * d;
      swap(c, d);
      u -= t * v;
      swap(u, v);
    }
    val = val * u % MOD;
    if (val < 0) val += MOD;
    return *this;
  }
  mll_ &operator+=(ll b) { return *this += mll_(b); }
  mll_ &operator-=(ll b) { return *this -= mll_(b); }
  mll_ &operator*=(ll b) { return *this *= mll_(b); }
  mll_ &operator/=(ll b) { return *this /= mll_(b); }
  bool operator==(const mll_ &b) { return val == b.val; }
  bool operator!=(const mll_ &b) { return val != b.val; }
  bool operator==(ll b) { return *this == mll_(b); }
  bool operator!=(ll b) { return *this != mll_(b); }
  friend bool operator==(ll a, const mll_ &b) { return mll_(a) == b.val; }
  friend bool operator!=(ll a, const mll_ &b) { return mll_(a) != b.val; }
  friend ostream &operator<<(ostream &os, const mll_ &a) { return os << a.val; }
  friend istream &operator>>(istream &is, mll_ &a) { return is >> a.val; }
  static mll_ Combination(ll a, ll b) {
    chmin(b, a - b);
    if (b < 0) return mll_(0);
    mll_ c = 1;
    for (ll i = (0); i <= ((b)-1); i++) c *= a - i;
    for (ll i = (0); i <= ((b)-1); i++) c /= i + 1;
    return c;
  }
};
using mll = mll_<1000000007LL>;
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
using vvvvvmll = std::vector<vvvvmll>;
void solve() {
  ll n;
  cin >> n;
  vector<ll> a = cinv<ll>(n);
  ll all = 0;
  for (auto &&e : a) all ^= e;
  if (all == 0) {
    cout << "DRAW" << '\n';
    return;
  }
  ll ms = MSB(all);
  ll x = 0;
  ll y = 0;
  for (auto &&e : a) {
    if (Bit(e, ms) == 1)
      x++;
    else
      y++;
  }
  if (x % 4 == 1) {
    cout << "WIN" << '\n';
    return;
  }
  if (y % 2 == 0) {
    cout << "LOSE" << '\n';
    return;
  }
  cout << "WIN" << '\n';
  return;
}
int main() {
  ll t;
  cin >> t;
  for (ll i = (0); i <= (t - 1); i++) {
    solve();
  }
  return 0;
}

```