The tic-tac-toe game is starting on a tree of n vertices. Some vertices are already colored in white while the remaining are uncolored.

There are two players — white and black. The players make moves alternatively. The white player starts the game. In his turn, a player must select one uncolored vertex and paint it in his color.

The player wins if he paints some path of three vertices in his color. In case all vertices are colored and neither player won, the game ends in a draw.

Could you please find who will win the game or whether it ends as a draw, assuming both players play optimally? 

Input

The first line contains a single integer T (1 ≤ T ≤ 50 000) — the number of test cases. Then descriptions of T test cases follow.

The first line of each test contains a single integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of vertices in the tree.

Each of the following n - 1 lines contains integers v, u (1 ≤ v, u ≤ n) denoting an edge of the tree connecting vertices v and u.

The last line of a test case contains a string of letters 'W' (for white) and 'N' (for not colored) of length n denoting already colored vertices. Vertexes already colored in white are denoted as 'W'.

It's guaranteed that the given edges form a tree, that there is at least one uncolored vertex and that there is no path of three white vertices.

It's guaranteed that sum of all n among all test cases is at most 5 ⋅ 10^5.

Output

For every test case, print either "White", "Draw" or "Black", depending on the result of the game.

Example

Input


2
4
1 2
1 3
1 4
NNNW
5
1 2
2 3
3 4
4 5
NNNNN


Output


White
Draw

Note

In the first example, vertex 4 is already colored in white. The white player can win by coloring the vertex 1 in white first and the remaining vertex on his second turn. The process is illustrated with the pictures below.

<image>

In the second example, we can show that no player can enforce their victory.
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
int chkmin(T &a, T2 b) {
  return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
int chkmax(T &a, T2 b) {
  return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
  return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
  return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
  return a > b ? a : b;
}
template <class T>
T aabs(T a) {
  return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
  return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
  return a[first] < a[second];
}
template <class T>
bool sort2(T &a, T &b) {
  return a > b ? swap(a, b), 1 : 0;
}
struct __INIT__ {
  __INIT__() {
    fill((unsigned char *)&inf, (unsigned char *)&inf + sizeof(inf), 0x3f);
  }
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
                                       qu[55];
int f, qr;
inline void flush() {
  fwrite(obuf, 1, oS - obuf, stdout);
  oS = obuf;
}
inline void putc(char first) {
  *oS++ = first;
  if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
  for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                              (iS == iT ? EOF : *iS++))
                            : *iS++);
       c < '0' || c > '9';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    if (c == '-')
      f = -1;
    else if (c == EOF)
      return 0;
  for (first = 0; c <= '9' && c >= '0';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    first = first * 10 + (c & 15);
  first *= f;
  return 1;
}
inline bool read(char &first) {
  while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                               (iS == iT ? EOF : *iS++))
                            : *iS++)) == ' ' ||
         first == '\n' || first == '\r')
    ;
  return first != EOF;
}
inline bool read(char *first) {
  while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                                (iS == iT ? EOF : *iS++))
                             : *iS++)) == '\n' ||
         *first == ' ' || *first == '\r')
    ;
  if (*first == EOF) return 0;
  while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
    *(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                              (iS == iT ? EOF : *iS++))
                           : *iS++);
  *first = 0;
  return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
  return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
  if (!first) putc('0');
  if (first < 0) putc('-'), first = -first;
  while (first) qu[++qr] = first % 10 + '0', first /= 10;
  while (qr) putc(qu[qr--]);
  return 0;
}
inline bool write(char first) {
  putc(first);
  return 0;
}
inline bool write(const char *first) {
  while (*first) {
    putc(*first);
    ++first;
  }
  return 0;
}
inline bool write(char *first) {
  while (*first) {
    putc(*first);
    ++first;
  }
  return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
  return write(first) || write(second...);
}
struct Flusher_ {
  ~Flusher_() { flush(); }
} io_flusher_;
}  // namespace io
using io ::putc;
using io ::read;
using io ::write;
namespace run {
vector<int> to[500005];
char s[500005];
int deg[500005];
bitset<500005> a;
bool main() {
  int n;
  read(n);
  int u, v;
  for (int i = 1; i <= n; ++i) to[i].clear();
  for (int i = 1; i < n; ++i) {
    read(u, v);
    to[u].emplace_back(v);
    to[v].emplace_back(u);
  }
  for (int i = 1; i <= n; ++i) deg[i] = to[i].size();
  read(s + 1);
  if (n <= 2) return write("Draw\n");
  int c3 = 0;
  for (int i = 1; i <= n; ++i)
    if (deg[i] >= 4)
      return write("White\n");
    else if (deg[i] == 3) {
      int cnt = 0;
      for (auto j : to[i])
        if (deg[j] > 1) ++cnt;
      if (cnt > 1) return write("White\n");
      ++c3;
    } else if (deg[i] == 2) {
      if (deg[to[i][0]] >= 3 && deg[to[i][1]] >= 3) return write("White\n");
    }
  if (c3 >= 2 && n & 1) return write("White\n");
  for (int i = 1; i <= n; ++i) a[i] = s[i] == 'W';
  for (int i = 1; i <= n; ++i) {
    int cnt = 0;
    for (auto j : to[i]) cnt += a[j];
    if ((a[i] + cnt) >= 2) return write("White\n");
  }
  int s = 0;
  for (int i = 1; i <= n; ++i)
    if (a[i]) {
      if (deg[i] >= 3) return write("White\n");
      for (auto j : to[i])
        if (deg[j] >= 3) return write("White\n");
      if (deg[i] == 2 && (deg[to[i][0]] > 1 || deg[to[i][1]] > 1))
        return write("White\n");
      ++s;
    }
  if (s == 2 && n & 1) return write("White\n");
  if (s == 1 && !(n & 1)) {
    for (int i = 1; i <= n; ++i)
      if (deg[i] == 3) return write("White\n");
  }
  return write("Draw\n");
}
}  // namespace run
signed main() {
  int t;
  read(t);
  for (; t; --t) run::main();
  return 0;
}
