#include <bits/stdc++.h>

constexpr int pMod = 1E9 + 7;

template<typename T>
int Add(T x) {
  return x;
}

template<typename T>
int Mul(T x) {
  return x;
}

template<typename T, typename... Ts>
int Add(T x, Ts... y) {
  return (x + Add(y...)) % pMod;
}

template<typename T, typename... Ts>
int Mul(T x, Ts... y) {
  return int(1LL * x * Mul(y...) % pMod);
}

template<typename T, typename... Ts>
void AddC(T &x, Ts... y) {
  x = Add(x, y...);
}

template<typename T, typename... Ts>
void MulC(T &x, Ts... y) {
  x = Mul(x, y...);
}

int Power(int x, int k) {
  int res = 1;
  while (k) {
    if (k & 1) { MulC(res, x); }
    MulC(x, x), k >>= 1;
  }
  return res;
}

int Inv(int x) {
  return Power(x, pMod - 2);
}

constexpr int maxN = 1E5 + 1;

namespace Tools {
  int fac[maxN], invFac[maxN], inv[maxN];

  void Init(int N = maxN - 1) {
    fac[0] = inv[0] = 1;
    for (int i = 1; i <= N; i++) { fac[i] = Mul(i, fac[i - 1]); }
    invFac[N] = Inv(fac[N]);
    for (int i = N; i >= 1; i--) { invFac[i - 1] = Mul(invFac[i], i); }
    for (int i = 1; i <= N; i++) { inv[i] = Mul(invFac[i], fac[i - 1]); }
  }
}

namespace Subtask1 {
  int Solution(const std::vector<std::pair<int, int>> &edges,
               const std::vector<int> &id) {
    int ans = 1, N = (int) edges.size() + 1;

    std::vector<std::vector<int>> graph(N);
    for (auto t: edges) {
      int u, v;
      std::tie(u, v) = t;
      graph[u].emplace_back(v);
      graph[v].emplace_back(u);
    }

    std::function<void(int, int)> DFS = [&](int u, int prt) {
      int tot = 0;
      for (auto v: graph[u]) {
        if (v == prt) { continue; }
        DFS(v, u), tot++;
      }
      MulC(ans, Tools::fac[tot]);
    };

    int u, v;
    std::tie(u, v) = edges[id[0]];
    DFS(u, v), DFS(v, u);
    return ans;
  }
}

namespace Solution {
  int Solution(const std::vector<std::pair<int, int>> &edges,
               const std::vector<int> &ids) {
    int ans = 0, N = (int) edges.size() + 1;
    std::vector<int> deg(N), vis(N);
    std::vector<std::vector<std::pair<int, int>>> graph(N);

    for (int i = 0; i < N - 1; i++) {
      int u, v;
      std::tie(u, v) = edges[i];
      graph[u].emplace_back(v, i);
      graph[v].emplace_back(u, i);
      deg[u]++, deg[v]++;
    }

    for (auto v: ids) { vis[v] = true; }
    std::vector<int> dp(N);

    std::function<void(int, int, int)> DFS = [&](int u, int prt, int pvis) {
      int mul = Tools::inv[deg[u] - 1];

      for (auto t: graph[u]) {
        int v, id;
        std::tie(v, id) = t;
        if (v == prt) { continue; }
        DFS(v, u, vis[id]);
        AddC(ans, Mul(dp[u], dp[v], mul));
        AddC(dp[u], dp[v]);
      }
      
      MulC(dp[u], mul);
      if (pvis) {
        AddC(ans, -dp[u]);
        AddC(dp[u], -dp[u], -1);
      }
    };

    DFS(0, -1, 0);

    int sum = 1;
    for (int i = 0; i < N; i++) {
      MulC(sum, Tools::fac[deg[i] - 1]);
    }

    ans = Add(Mul((int) ids.size(), sum), -Mul(ans, sum));
    return Add(ans, pMod);
  }
}

int main() {
  freopen("traverse.in", "r", stdin);
  freopen("traverse.out", "w", stdout);
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  Tools::Init();

  int cid, test;
  std::cin >> cid >> test;
  while (test--) {
    int N, K;
    std::cin >> N >> K;
    std::vector<std::pair<int, int>> edges(N - 1);
    std::vector<int> id(K);
    for (auto &t: edges) { 
      int u, v;
      std::cin >> u >> v, u--, v--;
      t = std::make_pair(u, v);
    }
    for (auto &v: id) { std::cin >> v, v--; }

    if (cid <= 6 && false) {
      std::cout << Subtask1::Solution(edges, id) << '\n';
    } else {
      std::cout << Solution::Solution(edges, id) << '\n';
    }
  }

  return 0;
}