#include <bits/stdc++.h> #define REP(i, n) for (int i = 0; (i) < (int)(n); ++ (i)) #define REP3(i, m, n) for (int i = (m); (i) < (int)(n); ++ (i)) #define REP_R(i, n) for (int i = (int)(n) - 1; (i) >= 0; -- (i)) #define REP3R(i, m, n) for (int i = (int)(n) - 1; (i) >= (int)(m); -- (i)) #define ALL(x) begin(x), end(x) using namespace std; template <int32_t MOD> struct mint { int32_t value; mint() = default; mint(int32_t value_) : value(value_) {} inline mint<MOD> operator + (mint<MOD> other) const { int32_t c = this->value + other.value; return mint<MOD>(c >= MOD ? c - MOD : c); } inline mint<MOD> operator - (mint<MOD> other) const { int32_t c = this->value - other.value; return mint<MOD>(c < 0 ? c + MOD : c); } inline mint<MOD> operator * (mint<MOD> other) const { int32_t c = (int64_t)this->value * other.value % MOD; return mint<MOD>(c < 0 ? c + MOD : c); } inline mint<MOD> & operator += (mint<MOD> other) { this->value += other.value; if (this->value >= MOD) this->value -= MOD; return *this; } inline mint<MOD> & operator -= (mint<MOD> other) { this->value -= other.value; if (this->value < 0) this->value += MOD; return *this; } inline mint<MOD> & operator *= (mint<MOD> other) { this->value = (int64_t)this->value * other.value % MOD; if (this->value < 0) this->value += MOD; return *this; } inline mint<MOD> operator - () const { return mint<MOD>(this->value ? MOD - this->value : 0); } mint<MOD> pow(uint64_t k) const { mint<MOD> x = *this, y = 1; for (; k; k >>= 1) { if (k & 1) y *= x; x *= x; } return y; } mint<MOD> inv() const { return pow(MOD - 2); } // MOD must be a prime inline mint<MOD> operator / (mint<MOD> other) const { return *this * other.inv(); } inline mint<MOD> operator /= (mint<MOD> other) { return *this *= other.inv(); } inline bool operator == (mint<MOD> other) const { return value == other.value; } inline bool operator != (mint<MOD> other) const { return value != other.value; } }; template <int32_t MOD> mint<MOD> operator * (int64_t value, mint<MOD> n) { return mint<MOD>(value) * n; } template <int32_t MOD> mint<MOD> operator * (int32_t value, mint<MOD> n) { return mint<MOD>(value % MOD) * n; } template <int32_t MOD> ostream & operator << (ostream & out, mint<MOD> n) { return out << n.value; } template <int32_t MOD> mint<MOD> fact(int n) { static vector<mint<MOD> > memo(1, 1); while (n >= memo.size()) { memo.push_back(memo.back() * mint<MOD>(memo.size())); } return memo[n]; } template <int32_t PRIME> mint<PRIME> inv_fact(int n) { static vector<mint<PRIME> > memo; if (memo.size() <= n) { int l = memo.size(); int r = n * 1.3 + 100; memo.resize(r); memo[r - 1] = fact<PRIME>(r - 1).inv(); for (int i = r - 2; i >= l; -- i) { memo[i] = memo[i + 1] * (i + 1); } } return memo[n]; } template <int32_t MOD> mint<MOD> choose(int n, int r) { assert (0 <= r and r <= n); return fact<MOD>(n) * inv_fact<MOD>(n - r) * inv_fact<MOD>(r); } template <int32_t MOD> mint<MOD> permute(int n, int r) { assert (0 <= r and r <= n); return fact<MOD>(n) * inv_fact<MOD>(n - r); } constexpr int MOD = 1e9 + 7; mint<MOD> solve(int n, int k) { mint<MOD> ans = 0; REP (i, n + 1) { mint<MOD> a = (mint<MOD>(1) - mint<MOD>(k) / mint<MOD>(n)) * permute<MOD>(n, k); mint<MOD> b = (i == n or k == 1) ? 0 : choose<MOD>(k, 2) * permute<MOD>(n - 2, k - 2); ans += i * (a + b); } return ans; } int main() { int n, k; cin >> n >> k; cout << solve(n, k).value << endl; return 0; }