#include <bits/stdc++.h>
#define err(args...) {}
#ifdef DEBUG
#include "_debug.cpp"
#endif
using namespace std;
using ll = long long;
using ld = long double;
template <typename T> using lim = numeric_limits<T>;
template <typename T> istream& operator>>(istream& is, vector<T>& a) { for(T& x : a) { is >> x; } return is; }
template <typename T> constexpr T fpow_eq(T& x, ll y, T identity = 1) {
    for(; y > 0; x *= x, y >>= 1) {
        if(y & 1) {
            identity *= x;
        }
    }
    return x = identity;
}
template <typename T> constexpr T fpow(T x, ll y, T identity = 1) { return fpow_eq(x, y, identity); }
#ifndef __TOTIENT_INCLUDED_
#define __TOTIENT_INCLUDED_
template <typename T, typename TEachDivisor, typename TEachPrime>
constexpr void factorize(T n, TEachDivisor each_divisor, TEachPrime each_prime = [](T) {}) {
    static_assert(is_convertible<decltype(each_divisor), function<void(T)>>::value, "each_divisor must be void(T)");
    static_assert(is_convertible<decltype(each_prime), function<void(T)>>::value, "each_prime must be void(T)");
    for(T i = 2; i * i <= n; i++) {
        if(n % i == 0) {
            each_prime(i);
            while(n % i == 0) {
                each_divisor(i);
                n /= i;
            }
        }
    }
    if(n > 1) {
        each_divisor(n);
        each_prime(n);
    }
}
template <typename T> constexpr T phi(T n) {
    T ans = n;
    factorize<T>(n, [](T) {}, [&](T p) { ans -= ans / p; });
    return ans;
}
#endif
#ifdef __TOTIENT_INCLUDED_
template <int M, int PHI_M = phi(M)> struct modint {
#else
template <int M, int PHI_M> struct modint {
#endif
    static constexpr int MOD = M;
    int val;
    constexpr modint() : val(0) {}
    constexpr modint(int val) : val(val % M) { this->val += this->val < 0 ? M : 0; }
    constexpr modint(long long val) : modint(int(val % M)) {}
    constexpr modint(const modint& m) : val(m.val) {}
    constexpr modint(const complex<long double>& x) : modint(llround(x.real())) {}
    constexpr explicit operator int() const { return val; }
    constexpr bool operator==(const modint& y) const { return val == y.val; }
    constexpr bool operator!=(const modint& y) const { return val != y.val; }
    constexpr bool operator< (const modint& y) const { return val <  y.val; }
    constexpr bool operator<=(const modint& y) const { return val <= y.val; }
    constexpr bool operator> (const modint& y) const { return val >  y.val; }
    constexpr bool operator>=(const modint& y) const { return val >= y.val; }
    constexpr modint& operator=(const modint& y) { val = y.val; return *this; }
    constexpr modint& operator+=(const modint& y) { val += y.val; val -= val >= M ? M : 0; return *this; }
    constexpr modint& operator-=(const modint& y) { val -= y.val; val += val <  0 ? M : 0; return *this; }
    constexpr modint& operator*=(const modint& y) { val = ll(val) * y.val % M; return *this; }
    constexpr modint& operator/=(const modint& y) { val = ll(val) * fpow(y, PHI_M - 1).val % M; return *this; }
    constexpr modint& operator^=(ll y) { fpow_eq(*this, y); return *this; }
    constexpr modint operator+(const modint& y) const { return modint(val) += y; }
    constexpr modint operator-(const modint& y) const { return modint(val) -= y; }
    constexpr modint operator*(const modint& y) const { return modint(val) *= y; }
    constexpr modint operator/(const modint& y) const { return modint(val) /= y; }
    constexpr modint operator^(ll y) const { return modint(val) ^= y; }
    constexpr modint operator-() const { return modint(0) -= *this; }
    constexpr modint operator~() const { return modint(1) /= *this; }
    constexpr modint& operator++() { val = val == M - 1 ? 0 : val + 1; return *this; }
    constexpr modint& operator--() { val = val == 0 ? M - 1 : val - 1; return *this; }
    constexpr modint operator++(int) { modint m = *this; ++(*this); return m; }
    constexpr modint operator--(int) { modint m = *this; --(*this); return m; }
    friend constexpr modint operator+(long long x, const modint& y) { return modint(x) + y; }
    friend constexpr modint operator*(long long x, const modint& y) { return modint(x) * y; }
    friend constexpr modint operator-(long long x, const modint& y) { return modint(x) - y; }
    friend constexpr modint operator/(long long x, const modint& y) { return modint(x) / y; }
    friend ostream& operator<<(ostream& os, const modint& m) { return os << m.val; }
    friend istream& operator>>(istream& is, modint& m) { ll val; is >> val; m = modint(val); return is; }
};
constexpr int M = 1'000'000'007;
using mint = modint<M, M - 1>;
mint operator""_m(unsigned long long int x) { return mint(ll(x)); }
template <typename T = mint> T fact(int n) {
    static vector<T> fac = {1};
    while(fac.size() <= n) {
        fac.push_back(fac.back() * int(fac.size()));
    }
    return fac[n];
}
template <typename T = mint> T fact_inv(int n) {
    static vector<T> inv_fac = {1};
    while(inv_fac.size() <= n) {
        inv_fac.push_back(inv_fac.back() / int(inv_fac.size()));
    }
    return inv_fac[n];
}
template <int N> constexpr modint<N, phi(N)> primitive_root() {
    for(modint<N, phi(N)> a = 2; a <= N - 1; a++) {
        bool is_primitive_root = true;
        factorize<ll>(phi(N), [](ll) {}, [&](ll p) {
            is_primitive_root &= (a ^ (phi(N) / p)) != 1;
        });
        if(is_primitive_root) {
            return a;
        }
    }
    return 0;
}
template <typename T = modint<998244353, 998244352>> T w(int len, bool inverse) {
    constexpr int M1 = T::MOD - 1;
    constexpr int K = M1 & -M1;
    constexpr T W = primitive_root<T::MOD>() ^ (M1 / K);
    return ((inverse ? ~W : W) ^ (K / len));
}
constexpr int lg(int x) { return 31 - __builtin_clz(x); }
template <typename T> vector<T>& pad(vector<T>& a, int min_size) {
    a.resize(2 << lg(min_size - 1));
    return a;
}
int bit_reverse(int i, int n) {
    int ans = 0;
    for(int j = 0; j < lg(n); j++) {
        ans |= i & (1 << j) ? 1 << (lg(n) - 1 - j) : 0;
    }
    return ans;
}
template <typename T> vector<T>& fft(vector<T>& a, bool inverse = false) {
    int n = a.size();
    for(int i = 0; i < n; i++) {
        if(i < bit_reverse(i, n)) {
            swap(a[i], a[bit_reverse(i, n)]);
        }
    }
    for(int len = 2; len <= n; len <<= 1) {
        T W = w<T>(len, inverse);
        for(int i = 0; i < n; i += len) {
            T root = 1;
            for(int j = i; j < i + (len >> 1); j++) {
                T u = a[j], t = root * a[j + (len >> 1)];
                a[j] = u + t;
                a[j + (len >> 1)] = u - t;
                root *= W;
            }
        }
    }
    if(inverse) {
        transform(a.begin(), a.end(), a.begin(), [n](T& ai) { return ai / T(n); });
    }
    return a;
}
template <typename T> vector<T>& operator*=(vector<T>& a, vector<T>& b) {
    fft(pad(a, a.size())); if(addressof(a) != addressof(b)) fft(pad(b, b.size()));
    assert(a.size() == b.size());
    transform(a.begin(), a.end(), b.begin(), a.begin(), multiplies<T>());
    fft(a, true); if(addressof(a) != addressof(b)) fft(b, true);
    return a;
}
template <typename T> vector<T> operator*(vector<T> a, vector<T>& b) { return a *= b; }
template <int M> vector<modint<M, M - 1>> solve(int n, int m, int k) {
    vector<modint<M, M - 1>> a(m + k + 1);
    for(int i = 0; i <= m + k; i++) {
        a[i] = fact<modint<M, M - 1>>(n - 1 + i);
    }
    vector<modint<M, M - 1>> b(k + 1);
    for(int j = 0; j <= k; j++) {
        b[j] = fact_inv<modint<M, M - 1>>(j) * (modint<M, M - 1>(3) ^ (k - j));
    }
    reverse(b.begin(), b.end());
    b.resize(a.size());
    a *= b;
    return a;
}
void ex_gcd(ll a, ll b, ll& x, ll& y) {
    if(b == 0) {
        x = 1, y = 0;
    } else {
        ll xx, yy;
        ex_gcd(b, a % b, xx, yy);
        x = yy, y = xx - a / b * yy;
    }
}
const int M1 = 998244353;
const int M2 = 469762049;
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m, k;
    cin >> n >> m >> k;
    auto a1 = solve<M1>(n, m, k);
    auto a2 = solve<M2>(n, m, k);
    ll m1, m2;
    ex_gcd(M1, M2, m1, m2);
    mint ans = 0;
    for(int i = 0; i <= m; i++) {
        mint x = mint(a1[k + i].val) * m2 * M2 + mint(a2[k + i].val) * m1 * M1;
        ans += fact_inv(n - 1) * fact_inv(i) * (3_m ^ (m - i)) * x;
    }
    cout << ans << endl;
    return 0;
}
