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;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto &x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
using ii = pair<long long, long long>;
using vb = vector<bool>;
using vi = vector<long long>;
using vii = vector<ii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
bool degree4(const vvi &g) {
  for (long long i = 0; i < (long long)g.size(); i++) {
    if (g[i].size() >= 4) return true;
  }
  return false;
}
bool internal_white(const vvi &g, const string &color) {
  for (long long i = 0; i < (long long)g.size(); i++) {
    if (g[i].size() >= 2 and color[i] == 'W') return true;
  }
  return false;
}
bool check122(long long x, const vvi &g) {
  long long one = 0;
  long long two = 0;
  for (long long v : g[x]) {
    if (g[v].size() == 1) one++;
    if (g[v].size() >= 2) two++;
  }
  if (two >= 3 or (one >= 1 and two >= 2)) return true;
  return false;
}
bool check_all122(const vvi &g) {
  for (long long i = 0; i < (long long)g.size(); i++) {
    if (check122(i, g)) return true;
  }
  return false;
}
bool is_bamboo(const vvi &g) {
  for (long long i = 0; i < (long long)g.size(); i++) {
    if (g[i].size() > 2) return false;
  }
  return true;
}
bool solve_bamboo(const vvi &g, const string &color) {
  long long len = g.size();
  long long white = 0;
  for (long long i = 0; i < (long long)color.length(); i++) {
    if (color[i] == 'W') white++;
  }
  if (white == 1 or white == 0) return false;
  return (len % 2 == 1);
}
bool internal_white_nbr(const vvi &g, const string &color) {
  for (long long i = 0; i < (long long)g.size(); i++) {
    if (g[i].size() >= 3) {
      for (long long v : g[i]) {
        if (color[v] == 'W') return true;
      }
    }
  }
  return false;
}
bool is_small(const vvi &g) { return g.size() <= 3; }
bool solve_small(const vvi &g, const string &color) {
  long long n = g.size();
  if (n < 3) return false;
  long long white = 0;
  for (long long i = 0; i < (long long)color.size(); i++) {
    if (color[i] == 'W') white++;
  }
  return (white == 2);
}
bool is_arrow(const vvi &g) {
  long long deg3 = 0;
  for (long long i = 0; i < (long long)g.size(); i++) {
    if (g[i].size() == 3) {
      deg3++;
    }
  }
  return deg3 == 1;
}
bool solve_arrow(const vvi &g, const string &color) {
  bool white = false;
  for (char ch : color)
    if (ch == 'W') white = true;
  if (not white) return false;
  long long n = g.size() - 2;
  return (n % 2 == 0);
}
bool is_twinfork(const vvi &g) {
  long long deg3 = 0;
  for (long long i = 0; i < (long long)g.size(); i++) {
    if (g[i].size() == 3) deg3++;
  }
  return (deg3 == 2);
}
bool solve_twinfork(const vvi &g) {
  long long n = g.size();
  return (n % 2 == 1);
}
bool solve() {
  long long n;
  cin >> n;
  vvi g(n);
  string color;
  for (long long i = 0; i < n - 1; i++) {
    long long x, y;
    cin >> x >> y;
    x--;
    y--;
    g[x].push_back(y);
    g[y].push_back(x);
  }
  cin >> color;
  if (is_small(g)) return solve_small(g, color);
  if (degree4(g)) return true;
  if (internal_white(g, color)) return true;
  if (internal_white_nbr(g, color)) return true;
  if (check_all122(g)) return true;
  if (is_bamboo(g)) return solve_bamboo(g, color);
  if (is_arrow(g)) return solve_arrow(g, color);
  if (is_twinfork(g)) return solve_twinfork(g);
  assert(false);
  return false;
}
int32_t main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  long long t;
  cin >> t;
  while (t--) {
    bool res = solve();
    cout << (res ? "White" : "Draw") << '\n';
  }
}
