You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions: 

  * each integer must be greater than 0; 
  * the product of all n-1 numbers should be equal to k; 
  * the number of 1-s among all n-1 integers must be minimum possible. 



Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.

Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.

In this problem, since the number k can be large, the result of the prime factorization of k is given instead.

Input

The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.

The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.

Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.

Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.

Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.

It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.

Output

Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.

Example

Input


3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3


Output


17
18
286

Note

In the first test case, one of the optimal ways is on the following image:

<image>

In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.

In the second test case, one of the optimal ways is on the following image:

<image>

In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using namespace std;
template <typename T>
inline bool read(T& ret) {
  T x = 0, f = 1;
  char ch = getchar();
  while (ch != EOF && (ch > '9' || ch < '0')) {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  if (EOF == ch) return false;
  do x = x * 10 + ch - 48, ch = getchar();
  while (ch >= '0' && ch <= '9');
  ret = x * f;
  return true;
}
inline char nc() {
  static char buf[100000], *p1 = buf, *p2 = buf;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
template <typename T>
bool rn(T& v) {
  static char ch;
  while (ch != EOF && !isdigit(ch)) ch = nc();
  if (ch == EOF) return false;
  for (v = 0; isdigit(ch); ch = nc()) v = v * 10 + ch - '0';
  return true;
}
template <typename T>
void o(T p) {
  static int stk[70], tp;
  if (p == 0) {
    putchar('0');
    return;
  }
  if (p < 0) {
    p = -p;
    putchar('-');
  }
  while (p) stk[++tp] = p % 10, p /= 10;
  while (tp) putchar(stk[tp--] + '0');
}
LL bin(LL x, LL n, LL MOD) {
  LL ret = MOD != 1;
  for (x %= MOD; n; n >>= 1, x = x * x % MOD)
    if (n & 1) ret = ret * x % MOD;
  return ret;
}
inline LL get_inv(LL x, LL p) { return bin(x, p - 2, p); }
const int MOD = 1e9 + 7;
int N, M;
const int MAXN = 1e5 + 10;
void Solve() {
  cin >> N;
  vector<int> G[MAXN];
  int ind[MAXN];
  memset(ind, 0, sizeof(ind));
  for (int i = 1; i < N; i++) {
    int u, v;
    cin >> u >> v;
    G[u].push_back(v);
    G[v].push_back(u);
    ind[u]++;
    ind[v]++;
  }
  vector<LL> P;
  cin >> M;
  for (int i = 0; i < M; i++) {
    int x;
    cin >> x;
    P.push_back(x);
  }
  queue<int> Q;
  for (int u = 0; u < N; u++) {
    if (1 == ind[u]) {
      Q.push(u);
    }
  }
  vector<int> V(N + 10, 1);
  vector<LL> S;
  while (!Q.empty()) {
    int u = Q.front();
    Q.pop();
    ind[u]--;
    if (0 == ind[u]) S.push_back(1LL * V[u] * (N - V[u]));
    for (auto v : G[u]) {
      if (ind[v] <= 0) continue;
      ind[v]--;
      V[v] += V[u];
      if (ind[v] == 1) {
        Q.push(v);
      }
    }
  }
  sort(S.begin(), S.end());
  sort(P.begin(), P.end());
  int ns = N - 1, np = M;
  LL ans = 0;
  if (ns <= np) {
    for (int i = ns; i < np; i++) {
      P[ns - 1] = P[ns - 1] * P[i] % MOD;
    }
    for (int i = 0; i < ns; i++) {
      ans = ans + S[i] % MOD * P[i];
      ans %= MOD;
    }
  } else {
    for (int i = S.size() - M - 1; i >= 0; i--) {
      ans += S[i];
      ans %= MOD;
    }
    for (int i = 0; i < M; i++) {
      ans = ans + S[S.size() - M + i] % MOD * P[i];
      ans %= MOD;
    }
  }
  cout << ans << endl;
}
int main() {
  std::ios::sync_with_stdio(false);
  int T;
  cin >> T;
  while (T--) Solve();
  return 0;
  return 0;
}
