#include <bits/stdc++.h>
using namespace std;
template <typename T>
class Modular {
 public:
  using Type = typename decay<decltype(T::value)>::type;
  constexpr Modular() : value() {}
  template <typename U>
  Modular(const U& x) {
    value = normalize(x);
  }
  template <typename U>
  static Type normalize(const U& x) {
    Type v;
    if (-mod() <= x && x < mod())
      v = static_cast<Type>(x);
    else
      v = static_cast<Type>(x % mod());
    if (v < 0) v += mod();
    return v;
  }
  const Type& operator()() const { return value; }
  template <typename U>
  explicit operator U() const {
    return static_cast<U>(value);
  }
  constexpr static Type mod() { return T::value; }
  Modular& operator+=(const Modular& other) {
    if ((value += other.value) >= mod()) value -= mod();
    return *this;
  }
  Modular& operator-=(const Modular& other) {
    if ((value -= other.value) < 0) value += mod();
    return *this;
  }
  template <typename U>
  Modular& operator+=(const U& other) {
    return *this += Modular(other);
  }
  template <typename U>
  Modular& operator-=(const U& other) {
    return *this -= Modular(other);
  }
  Modular& operator++() { return *this += 1; }
  Modular& operator--() { return *this -= 1; }
  Modular operator++(int) {
    Modular result(*this);
    *this += 1;
    return result;
  }
  Modular operator--(int) {
    Modular result(*this);
    *this -= 1;
    return result;
  }
  Modular operator-() const { return Modular(-value); }
  template <typename U = T>
  typename enable_if<is_same<typename Modular<U>::Type, int>::value,
                     Modular>::type&
  operator*=(const Modular& rhs) {
    value = normalize(static_cast<int64_t>(value) *
                      static_cast<int64_t>(rhs.value));
    return *this;
  }
  template <typename U = T>
  typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
                     Modular>::type&
  operator*=(const Modular& rhs) {
    int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
                                     rhs.value / mod());
    value = normalize(value * rhs.value - q * mod());
    return *this;
  }
  template <typename U = T>
  typename enable_if<!is_integral<typename Modular<U>::Type>::value,
                     Modular>::type&
  operator*=(const Modular& rhs) {
    value = normalize(value * rhs.value);
    return *this;
  }
  Modular& operator/=(const Modular& other) {
    return *this *= Modular(inverse(other.value, mod()));
  }
  template <typename U>
  friend const Modular<U>& abs(const Modular<U>& v) {
    return v;
  }
  template <typename U>
  friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
  template <typename U>
  friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
  template <typename U>
  friend std::istream& operator>>(std::istream& stream, Modular<U>& number);

 private:
  Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
  return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
  return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
  return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
  return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
  return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
  return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
  return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
  return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
  return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
  return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
  return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
  assert(b >= 0);
  Modular<T> x = a, res = 1;
  U p = b;
  while (p > 0) {
    if (p & 1) res *= x;
    x *= x;
    p >>= 1;
  }
  return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
  return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
  return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
  return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
  typename common_type<typename Modular<T>::Type, int64_t>::type x;
  stream >> x;
  number.value = Modular<T>::normalize(x);
  return stream;
}
constexpr int md = 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
const int N = 1e5 + 3;
const int nlog = 18;
int pr[N][nlog];
int pos[N], End[N];
vector<int> edge[N];
void dfs(int u, int p = 0) {
  static int count = 0;
  pos[u] = ++count;
  pr[u][0] = p;
  for (int i = 1; i < nlog; ++i) pr[u][i] = pr[pr[u][i - 1]][i - 1];
  for (auto& v : edge[u]) {
    if (v == p) continue;
    dfs(v, u);
  }
  End[u] = count;
}
int anc(int x, int y) { return (pos[x] <= pos[y] && End[y] <= End[x]); }
int lca(int x, int y) {
  if (anc(x, y)) return x;
  if (anc(y, x)) return y;
  for (int i = nlog - 1; i >= 0; --i) {
    if (pr[x][i] && !anc(pr[x][i], y)) {
      x = pr[x][i];
    }
  }
  return pr[x][0];
}
template <typename T>
class Eins {
 public:
  vector<T> st;
  int n;
  Eins(int n = 0) : n(n) { st.resize(n + 1); }
  void update(int i, T val) {
    for (; i <= n; i += i & -i) st[i] += val;
  }
  T get(int i) {
    T ans{};
    for (; i; i -= i & -i) ans += st[i];
    return ans;
  }
};
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n, q;
  cin >> n >> q;
  for (int i = 1; i < n; ++i) {
    int u, v;
    cin >> u >> v;
    edge[u].emplace_back(v);
    edge[v].emplace_back(u);
  }
  dfs(1);
  Eins<int> Tree(n);
  vector<int> kt(n + 1);
  while (q--) {
    int N, m, r;
    cin >> N >> m >> r;
    vector<int> node(N + 1);
    for (int i = 1; i <= N; ++i) {
      int x;
      cin >> x;
      node[i] = x;
      kt[x] = 1;
      Tree.update(pos[x], 1);
      Tree.update(End[x] + 1, -1);
    }
    vector<int> num(N + 1);
    int fix = Tree.get(pos[r]);
    for (int i = 1; i <= N; ++i) {
      int P = lca(r, node[i]);
      int u = node[i];
      num[i] = -1 + Tree.get(pos[u]) + fix - Tree.get(pos[P]) * 2 + kt[P];
    }
    for (int i = 1; i <= N; ++i) {
      int u = node[i];
      Tree.update(pos[u], -1);
      Tree.update(End[u] + 1, 1);
      kt[u] = 0;
    }
    bool flag = true;
    for (int i = 1; i <= N; ++i) {
      if (num[i] >= m) {
        flag = false;
        break;
      }
    }
    if (!flag) {
      cout << "0\n";
      continue;
    }
    vector<Mint> dp(N + 1);
    dp[0] = 1;
    sort(num.begin() + 1, num.end());
    for (int i = 1; i <= N; ++i) {
      for (int j = min(i, m); ~j; --j) {
        if (j <= num[i]) {
          dp[j] = 0;
          continue;
        }
        dp[j] *= (j - num[i]);
        if (j) dp[j] += dp[j - 1];
      }
    }
    Mint ans = 0;
    for (int i = 1; i <= N; ++i) ans += dp[i];
    cout << ans << "\n";
  }
}
