#include <bits/stdc++.h>

using i64 = long long;
template<class T>
T qmi(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}

i64 mul(i64 a, i64 b, i64 p) {
    i64 res = a * b - i64(1.L * a * b / p) * p;
    res %= p;
    if (res < 0) {
        res += p;
    }
    return res;
}

template<int P>
struct modint {
    int x;
    constexpr modint() : x{} {}
    constexpr modint(i64 x) : x{norm(x % getmod())} {}

    static int mod;
    constexpr static int getmod() {
        if (P > 0) {
            return P;
        } else {
            return mod;
        }
    }
    constexpr static void setmod(int m) {
        mod = m;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getmod();
        }
        if (x >= getmod()) {
            x -= getmod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr modint operator-() const {
        modint res;
        res.x = norm(getmod() - x);
        return res;
    }
    constexpr modint inv() const {
        assert(x != 0);
        return qmi(*this, getmod() - 2);
    }
    constexpr modint &operator*= (modint v) & {
        x = 1LL * x * v.x % getmod();
        return *this;
    }
    constexpr modint &operator+= (modint v) & {
        x = norm(x + v.x);
        return *this;
    }
    constexpr modint &operator-= (modint v) & {
        x = norm(x - v.x);
        return *this;
    }
    constexpr modint &operator/= (modint v) & {
        return *this *= v.inv();
    }
    friend constexpr modint operator- (modint a, modint b) {
        modint res = a;
        res -= b;
        return res;
    }
    friend constexpr modint operator+ (modint a, modint b) {
        modint res = a;
        res += b;
        return res;
    }
    friend constexpr modint operator* (modint a, modint b) {
        modint res = a;
        res *= b;
        return res;
    }
    friend constexpr modint operator/ (modint a, modint b) {
        modint res = a;
        res /= b;
        return res;
    }
    friend constexpr std::istream &operator>> (std::istream& is, modint& a) {
        i64 v;
        is >> v;
        a = modint(v);
        return is;
    }
    friend constexpr std::ostream &operator<< (std::ostream& os, const modint& a) {
        return os << a.val();
    }
    friend constexpr bool operator== (modint a, modint b) {
        return a.val() == b.val();
    }
    friend constexpr bool operator!= (modint a, modint b) {
        return a.val() != b.val();
    }
};

constexpr int P = 1e9 + 7;
using mint = modint<P>;

struct Comb {
    int n;
    std::vector<mint> fact;
    std::vector<mint> invefact;
    std::vector<mint> inve;

    Comb() : n{0}, fact{1}, invefact{1}, inve{0} {}
    Comb(int n) : Comb() {
        init(n);
    }
    
    void init(int m) {
        if (m <= n) return;
        fact.resize(m + 1);
        invefact.resize(m + 1);
        inve.resize(m + 1);
        
        for (int i = n + 1; i <= m; i ++ ) {
            fact[i] = fact[i - 1] * i;
        }
        invefact[m] = fact[m].inv();
        for (int i = m; i > n; i -- ) {
            invefact[i - 1] = invefact[i] * i;
            inve[i] = invefact[i] * fact[i - 1];
        }
        n = m;
    }
    
    mint fac(int m) {
        if (m > n) init(2 * m);
        return fact[m];
    }
    mint invfac(int m) {
        if (m > n) init(2 * m);
        return invefact[m];
    }
    mint inv(int m) {
        if (m > n) init(2 * m);
        return inve[m];
    }
    mint binom(int n, int m) {
        if (n < m || m < 0) return 0;
        return fac(n) * invfac(m) * invfac(n - m);
    }
} comb;

int main() {
    // freopen("lake.in", "r", stdin);
    // freopen("lake.out", "w", stdout);
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m, k;
    std::cin >> n >> m >> k;

    std::vector<mint> pw2(n + 1), inv2(n + 1), pwk(n + 1);
    pw2[0] = pwk[0] = inv2[0] = 1;
    for (int i = 0; i < n; i ++ ) {
        pw2[i + 1] = pw2[i] * 2;
        pwk[i + 1] = pwk[i] * k;
        inv2[i + 1] = inv2[i] * qmi(mint(2), P - 2);
    }

    std::vector<std::vector<mint>> f(m + 1, std::vector<mint>(m + 1));
    for (int i = 0; i <= m; i ++ ) {
        f[i][0] = 1;
        for (int j = 0; j < m; j ++ ) {
            f[i][j + 1] = f[i][j] * (k - i - j);
        }
    }

    auto C = [&](int n, int m) -> mint {
        if (n < m || m < 0) {
            return 0;
        }
        return f[k - n][m] * comb.invfac(m);
    };

    std::vector<mint> g(m + 1);
    for (int len = 0; len <= m; len ++ ) {
        // for (int i = 0; i <= (m - 2 * len) / 2; i ++ ) {
        //     g[len] += comb.binom(k, len) * comb.fac(len) * comb.binom(k - len, i) * comb.binom(k - len - i, m - 2 * len - 2 * i) * comb.fac(m - 2 * len) * qmi(pw2[i], P - 2);
        // }
        // std::cerr << len << " " << g[len] << "\n";
        for (int i = 0; i <= (m - 2 * len) / 2; i ++ ) {
            g[len] += C(k - len, i) * C(k - len - i, m - 2 * i - 2 * len) * comb.fac(m - 2 * len) * inv2[i];
        }
        g[len] *= f[0][len];
        // std::cerr << len << " " << g[len] << "\n";
    }
    // for (int i = m - 1; i >= 0; i -- ) {
    //     g[i] -= g[i + 1];
    // }
    for (int i = 1; i <= m; i ++ ) {
        g[0] -= g[i];
    }

    mint ans = pwk[n - m] * (n - m + 1) * g[0];
    for (int len = 1; len <= m / 2; len ++ ) {
        mint sum = 0;
        for (int k = 1; len + k * (m - len) <= n; k ++ ) {
            int x = len + k * (m - len);
            sum += (k % 2 ? 1 : -1) * (n - x + 1) * pwk[n - x];
        }
        ans += sum * g[len];
    }
    std::cout << ans << "\n";

    return 0;
}