#if __INCLUDE_LEVEL__ == 0 #include __BASE_FILE__ namespace { using mint = atcoder::modint1000000007; Comb comb(1e7); mint g(int n, int k) { mint ret = 0; for (const int i : rep(n / 2 + 1)) { const int n2 = n - i; const int k2 = k - i * 2; if (k2 < 0 || n2 < k2) { continue; } ret += comb.binom(n, i) * comb.binom(n2, k2) * mint(3).pow(k2) * mint(2).pow(n2 - k2); } return ret; } mint f(int n, int m) { mint ret = 0; for (const int i : rep(m)) { ret += comb.binom(m - 1, i) * g(n - m, n - m - i - 1); } ret *= m; ret *= comb.recip(n - m); return ret; } void solve() { int n, k, q; scan(n, k, q); while (q--) { int m; scan(m); if (m < n) { print(f(n, m)); } else { print(1); } } } } // namespace int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout << std::setprecision(DBL_DECIMAL_DIG); solve(); } #else // __INCLUDE_LEVEL__ #include #include template std::vector make_vector_for_overwrite(int n) { static_assert(std::is_trivially_destructible_v); std::vector v; static_assert(sizeof(v) == 3 * sizeof(T*)); v.reserve(n); T*(&a)[3] = reinterpret_cast(v); assert(a[0] == a[1] && a[1] + n == a[2]); a[1] = a[2]; return v; } template class Comb { public: Comb() = default; explicit Comb(int max_n) : fact_(make_vector_for_overwrite(max_n + 1)), recip_fact_(make_vector_for_overwrite(max_n + 1)) { fact_[0] = 1; for (const int n : std::views::iota(1, max_n + 1)) { fact_[n] = fact_[n - 1] * n; } recip_fact_[max_n] = 1 / fact_[max_n]; for (const int n : std::views::iota(1, max_n + 1) | std::views::reverse) { recip_fact_[n - 1] = n * recip_fact_[n]; } } T recip(int n) const { assert(n); return n < 0 ? -recip(-n) : recip_fact_[n] * fact_[n - 1]; } T fact(int n) const { assert(0 <= n); return fact_[n]; } T recip_fact(int n) const { return n < 0 ? 0 : recip_fact_[n]; } T falling_fact(int n, int k) const { assert(0 <= n || n < k); if (n < 0) { const T t = falling_fact(k - n - 1, k); return k & 1 ? -t : t; } return n < k ? 0 : recip_fact(n - k) * fact(n); } T recip_falling_fact(int n, int k) const { assert(n < 0 || k <= n); return falling_fact(n - k, -k); } T rising_fact(int n, int k) const { assert(n <= 0 || 0 < n + k); return falling_fact(n + k - 1, k); } T recip_rising_fact(int n, int k) const { assert(0 < n || n + k <= 0); return falling_fact(n - 1, -k); } T binom(int n, int k) const { if ((n < 0) ^ (k < 0) ^ (n < k)) { return 0; } if (n < 0 && k < 0) { k = n - k; } return recip_fact(k) * falling_fact(n, k); } T recip_binom(int n, int k) const { assert((0 <= n) ^ (0 <= k) ^ (k <= n)); k = std::max(k, n - k); return recip_falling_fact(n, k) * fact(k); } T multiset(int n, int k) const { return binom(n + k - 1, k); } T recip_multiset(int n, int k) const { assert((0 < n) ^ (0 <= k) ^ (0 < n + k)); return recip_binom(n + k - 1, k); } private: std::vector fact_; std::vector recip_fact_; }; template bool chmin(T& x, U&& y) { return y < x && (x = std::forward(y), true); } template bool chmax(T& x, U&& y) { return x < y && (x = std::forward(y), true); } template T inf() { T ret; std::memset(&ret, 0x3f, sizeof(ret)); return ret; } template T inf() { return std::numeric_limits::infinity(); } template concept Range = std::ranges::range && !std::convertible_to; template concept Tuple = std::__is_tuple_like::value && !Range; namespace std { istream& operator>>(istream& is, Range auto&& r) { for (auto&& e : r) { is >> e; } return is; } istream& operator>>(istream& is, Tuple auto&& t) { return apply([&](auto&... xs) -> istream& { return (is >> ... >> xs); }, t); } ostream& operator<<(ostream& os, Range auto&& r) { for (string_view sep = ""; auto&& e : r) { os << exchange(sep, " ") << e; } return os; } ostream& operator<<(ostream& os, Tuple auto&& t) { const auto f = [&](auto&... xs) -> ostream& { [[maybe_unused]] string_view sep = ""; ((os << exchange(sep, " ") << xs), ...); return os; }; return apply(f, t); } template * = nullptr> istream& operator>>(istream& is, T& x) { int v; is >> v; x = T::raw(v); return is; } template * = nullptr> ostream& operator<<(ostream& os, const T& x) { return os << x.val(); } } // namespace std void scan(auto&&... xs) { std::cin >> std::tie(xs...); } void print(auto&&... xs) { std::cout << std::tie(xs...) << '\n'; } template class fix { public: explicit fix(F f) : f_(std::move(f)) {} decltype(auto) operator()(auto&&... xs) const { return f_(std::ref(*this), std::forward(xs)...); } private: F f_; }; inline auto rep(int l, int r) { return std::views::iota(std::min(l, r), r); } inline auto rep(int n) { return rep(0, n); } inline auto rep1(int l, int r) { return rep(l, r + 1); } inline auto rep1(int n) { return rep(1, n + 1); } namespace ranges = std::ranges; namespace views = std::views; using i64 = std::int64_t; #endif // __INCLUDE_LEVEL__