#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 1e5;
const int mod = 1e9 + 7;
const int inv2 = 5e8 + 4;

inline int read() {
	char ch = getchar(); int x = 0;
	while (!isdigit(ch)) {ch = getchar();}
	while (isdigit(ch)) {x = x * 10 + ch - 48; ch = getchar();}
	return x;
}
inline int add(int x, int y) {x += y; return x >= mod ? x - mod : x;}
inline int del(int x, int y) {x -= y; return x < 0 ? x + mod : x;}
inline void Add(int &x, int y) {x = add(x, y);}
inline void Del(int &x, int y) {x = del(x, y);}
inline int qpow(int x, int y) {
	int res = 1;
	while (y) {
		if (y & 1) res = 1ll * res * x % mod;
		x = 1ll * x * x % mod;
		y >>= 1;
	}
	return res;
}

struct node {
	int x, y;
}e[N];
int ID, T, n, k, id[N], du[N], fac[N];
vector<int> g[N];

namespace subtask1 {
	int dp[N];
	
	void dfs(int x, int fa) {
		dp[x] = fac[du[x] - 1];
		for (auto y : g[x]) {
			if (y == fa) continue;
			dfs(y, x);
			dp[x] = 1ll * dp[x] * dp[y] % mod;
		}
	}
	
	void solve() {
		dfs(e[id[1]].x, 0);
		printf("%d\n", dp[e[id[1]].x]);
	}
}

namespace subtask2 {
	bool vis[N];
	
	bool dfs(int x, int fa) {
		if (x == e[id[2]].x || x == e[id[2]].y) return vis[x] = true;
		for (auto y : g[x]) {
			if (y == fa) continue;
			vis[x] |= dfs(y, x);
		}
		return vis[x];
	}
	
	void solve() {
		int ans = 2;
		for (int i = 1; i <= n; ++i) ans = 1ll * ans * fac[du[i] - 1] % mod;
		dfs(e[id[1]].x, e[id[1]].y); dfs(e[id[1]].y, e[id[1]].x);
		int tmp = 1;
		for (int i = 1; i <= n; ++i)
			if (vis[i]) tmp = 1ll * tmp * fac[du[i] - 2] % mod;
			else tmp = 1ll * tmp * fac[du[i] - 1] % mod;
		printf("%d\n", del(ans, tmp));
		for (int i = 1; i <= n; ++i) vis[i] = false;
	}
}

namespace subtask4 {
	int f[N][2], ans, depth[N], root, tot, val[N];
	bool can[N];
	
	void dfs(int x, int fa, int d) {
		depth[x] = d;
		for (auto y : g[x])
			if (y != fa) dfs(y, x, d + 1);
	}
	
	void dfs2(int x, int fa) {
		if (du[x] == 1) f[x][0] = 1, f[x][1] = 0;
		else {
			f[x][0] = f[x][1] = 0;
			for (auto y : g[x]) {
				if (y == fa) continue;
				dfs2(y, x);
				if (can[y]) {
					Add(ans, 1ll * f[x][0] * f[y][0] % mod);
					Add(f[x][0], 1ll * f[y][0] * val[x] % mod);
					Add(f[x][1], 1ll * f[y][0] * val[x] % mod);
				}else {
					Add(ans, 1ll * f[x][0] * f[y][1] % mod);
					Add(ans, 1ll * f[x][1] * f[y][0] % mod);
					Del(ans, 1ll * f[x][1] * f[y][1] % mod);
					Add(f[x][0], 1ll * f[y][0] * val[x] % mod);
					Add(f[x][1], 1ll * f[y][1] * val[x] % mod);
				}
			}
		}
	}
	
	void solve() {
		if (n == 2) return puts("1"), void();
		for (int i = 1; i <= n; ++i)
			if (du[i] != 1) {
				root = i;
				break;
			}
		dfs(root, 0, 1);
		for (int i = 1; i <= k; ++i) {
			if (depth[e[id[i]].x] < depth[e[id[i]].y]) swap(e[id[i]].x, e[id[i]].y);
			can[e[id[i]].x] = true;
		}
		tot = 1;
		for (int i = 1; i <= n; ++i) tot = 1ll * tot * fac[du[i] - 1] % mod, val[i] = qpow(du[i] - 1, mod - 2);
		ans = 0; dfs2(root, 0); printf("%d\n", 1ll * ans * tot % mod);
		for (int i = 1; i <= n; ++i) can[i] = false;
	}
}

int main() {
	freopen("traverse.in", "r", stdin);
	freopen("traverse.out", "w", stdout);
	ID = read(); T = read();
	fac[0] = 1;
	for (int i = 1; i <= M; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
	while (T--) {
		n = read(); k = read();
		for (int i = 1, x, y; i < n; ++i) {
			x = read(); y = read();
			e[i].x = x; e[i].y = y; du[x]++; du[y]++;
			g[x].push_back(y); g[y].push_back(x);
		}
		for (int i = 1; i <= k; ++i) id[i] = read();
		if (k == 1) subtask1 :: solve();
		else if (ID == 18) puts("1");
		else if (19 <= ID && ID <= 21) {
			int now = fac[n - 1];
			if (n - 1 - k >= 2) Del(now, 1ll * (n - 1 - k) * (n - 1 - k - 1) % mod * fac[n - 3] % mod);
			now = 1ll * now * inv2 % mod;
			printf("%d\n", now);
		}
		else if (k == 2) subtask2 :: solve();
		else subtask4 :: solve();
		for (int i = 1; i <= n; ++i) g[i].clear(), du[i] = 0;
	}
	return 0;
}