#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define pb push_back

const ld pi = 3.14159265358979323846;
const ll INF = 1e18;
const int mod = 998244353;

template <typename T>
struct Z{
    static const T Mod = (T)998244353;
    T num;

    Z() : num(0) {}

    Z(T n) : num(n % Mod) {
        if (num < 0) num += Mod;
    }

    Z operator+(const Z& other) const{
        T res = num + other.num;
        if(res >= Mod) res -= Mod;
        return Z(res);
    }

    Z operator-(const Z& other) const{
        T res = num - other.num;
        if(res < 0) res += Mod;
        return Z(res);
    }

    Z operator*(const Z& other) const{
        return Z((ll)num * other.num);
    }

    Z operator/(const Z& other) const{
        return (*this) * other.inverse();
    }

    Z pow(long long power) const{
        Z res(1);
        Z base(num);
        long long exp = power;
        while(exp > 0){
            if(exp & 1){
                res = res * base;
            }
            base = base * base;
            exp >>=1;
        }
        return res;
    }

    Z inverse() const{
        return pow(Mod - 2);
    }

    friend ostream& operator<<(ostream& os, const Z& z){
        os << z.num;
        return os;
    }
};

template <typename T>
struct Binom {
public:
    vector<Z<T>> fact;      
    vector<Z<T>> inv_fact;   

    Binom(int n) : fact(n + 1, Z<T>(1)), inv_fact(n + 1, Z<T>(1)) {
        for(int i =1; i <=n; i++){
            fact[i] = fact[i-1] * Z<T>(i);
        }
        inv_fact[n] = fact[n].inverse();
        for(int i = n-1; i >=0; i--){
            inv_fact[i] = inv_fact[i+1] * Z<T>(i+1);
        }
    }

   
    Z<T> comb(int n_val, int k_val) const{
        if(n_val < 0 || k_val < 0 || n_val < k_val){
            return Z<T>(0);
        }
        return fact[n_val] * inv_fact[k_val] * inv_fact[n_val - k_val];
    }

   
    Z<T> perm(int n_val, int k_val) const{
        if(n_val < k_val || k_val < 0){
            return Z<T>(0);
        }
        return fact[n_val] * inv_fact[n_val - k_val];
    }
};

void fast_zeta_transform(vector<int> &f, int B){
    for(int i=0; i < B; i++){
        for(int mask = 0; mask < (1 << B); mask++){
            if((mask & (1 << i)) ==0 ){
                f[mask] += f[mask | (1 << i)];
            }
        }
    }
}

void mobius_inversion(vector<Z<ll>> &g, int B){
    for(int i = 0; i < B; i++){
        for(int mask = 0; mask < (1 << B); mask++){
            if((mask & (1 << i)) ==0 ){
                g[mask] = g[mask] - g[mask | (1 << i)];
            }
        }
    }
}

void solve() {
    int n, k;
    ll m;
    cin >> n >> k >> m;

    int B = 0;
    while((1LL << B) <= m){
        B++;
    }
    B = max(B, 1);  

    int size = 1 << B;

    vector<int> f(size, 0);
    for(ll x = 1; x <= m; x++){
        f[x] += 1;
    }


    fast_zeta_transform(f, B);

    Binom<ll> binom(m); 
 
    vector<Z<ll>> P(size, Z<ll>(0));
    for(int c=0; c < size; c++){
        if(f[c] >= n){
            P[c] = binom.perm(f[c], n);
        }
    }

    vector<Z<ll>> g = P;  
    mobius_inversion(g, B);
 
    Z<ll> answer = 0;
    for(int c=0; c < size; c++){
        if(__builtin_popcount(c) >=k){
            answer = answer + g[c];
        }
    }
    cout << answer << endl;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t = 1;
    // cin >> t;

    while(t--){
        solve();
    }
    
    return 0;
}