#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int n, q;
struct Edge {
  int a, b, next;
  Edge() {}
  Edge(int a, int b, int next) : a(a), b(b), next(next) {}
} e[1000010];
int p[100010];
int tot;
void add(int a, int b) {
  e[tot] = Edge(a, b, p[a]);
  p[a] = tot++;
}
vector<int> g[1000010];
int in[1000010], out[1000010], path[1000010], id;
int f[100010], rmq[1000010][21];
int fa[1000010], dep[1000010];
int a[1000010];
long long dp[2][301];
void dfs(int t, int f) {
  fa[t] = f;
  path[id] = t;
  in[t] = id++;
  dep[t] = dep[f] + 1;
  for (int i : g[t]) {
    if (i == f) continue;
    dfs(i, t);
    path[id++] = t;
  }
}
void init() {
  for (int i = 0; i < id; ++i) {
    rmq[i][0] = path[i];
  }
  for (int j = 1; j <= 20; ++j) {
    for (int i = 0; i < id; ++i) {
      rmq[i][j] = dep[rmq[i][j - 1]] < dep[rmq[i + (1 << (j - 1))][j - 1]]
                      ? rmq[i][j - 1]
                      : rmq[i + (1 << (j - 1))][j - 1];
    }
  }
}
int lca(int a, int b) {
  if (in[a] > in[b]) swap(a, b);
  int s = in[a], e = in[b];
  int k = 0;
  for (; (1 << k) <= (e - s + 1); ++k)
    ;
  k--;
  return dep[rmq[s][k]] < dep[rmq[e - (1 << k) + 1][k]]
             ? rmq[s][k]
             : rmq[e - (1 << k) + 1][k];
}
int k, m, r;
int v[100010];
int num;
vector<int> nima;
void dfs1(int t, int fa) {
  f[t] = num;
  if (v[t]) {
    nima.push_back(t);
    ++num;
  }
  for (int i = p[t]; i != -1; i = e[i].next) {
    if (e[i].b == fa) continue;
    dfs1(e[i].b, t);
  }
  if (v[t]) --num;
}
int sol() {
  auto cmp = [&](const int i, int j) { return in[i] < in[j]; };
  for (int i = 0; i < k; ++i) {
    v[a[i]] = 1;
  }
  if (v[r] == 0) {
    a[k++] = r;
  }
  sort(a, a + k, cmp);
  int flag = 0;
  set<int> sb;
  vector<int> ft;
  for (int i = 0; i < k; ++i) {
    if (i == 0) {
      ft.push_back(a[i]);
      sb.insert(a[i]);
    } else {
      int lca_i = lca(a[i], a[i - 1]);
      if (sb.find(lca_i) == sb.end()) {
        sb.insert(lca_i);
        ft.push_back(lca_i);
      }
      sb.insert(a[i]);
      ft.push_back(a[i]);
    }
  }
  sort(ft.begin(), ft.end(), cmp);
  stack<int> st;
  memset(p, -1, sizeof(p));
  tot = 0;
  for (int i = 0; i < ft.size(); ++i) {
    while (!st.empty() && lca(ft[i], st.top()) != st.top()) st.pop();
    if (st.size()) {
      add(ft[i], st.top());
      add(st.top(), ft[i]);
    }
    st.push(ft[i]);
  }
  num = 0;
  nima.clear();
  dfs1(r, r);
  memset(dp, 0, sizeof(dp));
  dp[1][1] = 1;
  for (int i = 2; i <= nima.size(); ++i) {
    int index = i & 1;
    int pre = index ^ 1;
    memset(dp[index], 0, sizeof(dp[index]));
    for (int j = 1; j <= m; ++j) {
      dp[index][j] = (dp[pre][j - 1] + dp[pre][j] * (j - f[nima[i - 1]])) % mod;
    }
  }
  long long ans = 0;
  for (int i = 1; i <= m; ++i) {
    ans = (ans + dp[(nima.size()) & 1][i]) % mod;
  }
  for (int i = 0; i < nima.size(); ++i) {
    v[nima[i]] = 0;
  }
  return ans;
}
int main() {
  while (cin >> n >> q) {
    for (int i = 0; i < n - 1; ++i) {
      int u, v;
      scanf("%d%d", &u, &v);
      g[u].push_back(v);
      g[v].push_back(u);
    }
    id = 0;
    dfs(1, 1);
    init();
    for (int i = 0; i < q; ++i) {
      scanf("%d%d%d", &k, &m, &r);
      for (int j = 0; j < k; ++j) {
        scanf("%d", &a[j]);
      }
      cout << sol() << endl;
    }
  }
}
