#include<iostream>
#include<algorithm>
#include<stack>
#include<vector>
#include<set>
#include<string>
#include<cstdint>

using namespace std;
using ll = long long;

#include<atcoder/modint>
#include<atcoder/convolution>
using mint = atcoder::modint998244353;
#define conv(a,b) atcoder::convolution(a,b)
ostream& operator<<(ostream& os, const mint& m){
    os << m.val();
    return os;
}

template < typename mint >
struct FPS:vector<mint>{
    FPS(){}
    FPS(int n){
        this->resize(n);
    }
    FPS(vector<mint>a){
        *this = a;
    }
    FPS &operator+=(const FPS&r){
        if(r.size()>this->size()) this->resize(r.size());
        for(int i = 0;i<(int)r.size();i++) (*this)[i] += r[i];
        return *this;
    }
    FPS &operator+=(const mint&r){
        if(this->empty()) this->resize(1);
        (*this)[0] += r;
        return *this;
    }
    FPS &operator-=(const FPS&r){
        if(r.size()>this->size()) this->resize(r.size());
        for(int i = 0;i<(int)r.size();i++) (*this)[i] -= r[i];
        return *this;
    }
    FPS &operator-=(const mint&r){
        if(this->empty()) this->resize(1);
        (*this)[0] -= r;
        return *this;
    }
    FPS &operator*=(const FPS&r){
        vector<mint> nxt = conv(*this,r);
        this->resize(nxt.size());
        for(int i = 0;i<nxt.size();i++) (*this)[i] = nxt[i];
        return *this;
    }
    FPS &operator*=(const mint&r){
        for(int i = 0;i<(int)this->size();i++) (*this)[i] *= r;
        return *this;
    }
    FPS operator+(const FPS&r) const {return FPS(*this)+=r;}
    FPS operator+(const mint&r) const {return FPS(*this)+=r;}
    FPS operator-(const FPS&r) const {return FPS(*this)-=r;}
    FPS operator-(const mint&r) const {return FPS(*this)-=r;}
    FPS operator*(const FPS&r) const {return FPS(*this)*=r;}

    void print(){
        for(int i = 0;i<(int)this->size();i++){
            if(i) cout<<" ";
            cout<<(*this)[i];
        }
        cout<<endl;
    }

    int deg(){return (int)this->size()-1;}

    // f^-1 mod x^n
    FPS<mint> inv(int n){
        assert((*this)[0].val()!=0);
        FPS<mint> g(1);
        g[0] = 1/(*this)[0];
        ll now = 1;
        FPS<mint> tmp(1);
        tmp[0] = 2;
        while(now<n){
            g = g * (tmp-g*(*this));
            now <<= 1;
            if(g.size()>now) g.resize(now);
        }
        g.resize(n);
        return g;
    }

    FPS<mint> diff(){
        FPS<mint>g(this->size()-1);
        for(int i = 0;i+1<this->size();i++) g[i] = mint(i+1) * (*this)[i+1];
        return g;
    }

    FPS<mint> integral(){
        FPS<mint>g(this->size()+1);
        g[0] = 0;
        for(int i = 1;i<=this->size();i++) g[i] = (*this)[i-1] / mint(i);
        return g;
    }

    FPS<mint> log(int n){
        assert((*this)[0].val()==1);
        return ((*this).diff() * (*this).inv(n-1)).integral();
    }

    FPS<mint> exp(int n){
        assert((*this)[0].val()==0);
        FPS<mint> g(1);
        g[0] = 1;
        ll now = 1;
        FPS<mint> tmp(1);
        tmp[0] = 1;
        while(now<n){
            g = g * ((*this) + tmp - g.log(now<<1));
            now <<= 1;
            if(g.size()>now) g.resize(now);
        }
        return g;
    }
    
};

template < typename mint >
FPS<mint> pow(FPS<mint>&a,ll k,int n){
    FPS<mint> ans(n+1);
    ans[0] += 1;
    FPS<mint> tmp = a;
    tmp.resize(n+1);
    while(k){
        if(k&1){
            ans *= tmp;
            ans.resize(n+1);
        }
        tmp *= tmp;
        tmp.resize(n+1);
        k>>=1;
    }
    return ans;
}

mint fac[1<<17],ifac[1<<17];
int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    
    ll n,b,c;
    cin>>n>>b>>c;

    fac[0] = 1;
    for(int i = 1;i<1<<17;i++) fac[i] = fac[i-1] * i;
    for(int i = 0;i<1<<17;i++) ifac[i] = fac[i].inv();
    FPS<mint> f(n+1),g(n+1);
    FPS<mint> now(1);
    now[0] = 1;
    for(int i = 0;i<=n;i++){
        if(i%2==0) f[i] += fac[n] * ifac[i] * ifac[n-i];
        else g[i] += fac[n] * ifac[i] * ifac[n-i];
    }

    for(int i = 0;i<=60;i++){
        FPS<mint> nxt;
        if(c&1) nxt = now * g;
        else nxt =  now * f;
        now = FPS<mint>(1);
        for(int j = 0;j<nxt.size();j++){
            if(j>b) break;
            if(j%2==b%2){
                int want = j >> 1;
                if(want>=now.size()) now.resize(want+1);
                now[want] += nxt[j];
            }
        }
        c >>= 1;
        b >>= 1;
    }
    cout<<now[0].val()<<endl;
}