#include <bits/stdc++.h>
#include <bits/extc++.h>
#define double long double
#define rbtree __gnu_pbds::tree<int,__gnu_pbds::null_type,less<int>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>
#define int ll
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);
#define pb push_back
#define ALL(X) X.begin(),X.end()
#define F(i,n)  FF(i,0,n)
#define F1(i,n)  FF(i,1,n+1)
#define FF(i,n,m) for(int i=(int)n;i<(int)m;++i)
#ifndef LOCAL
//#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#else
#endif // LOCOL
//#define mp make_pair
using namespace std;
//using namespace __gnu_pbds;
template<typename T> bool remax(T& a, const T& b) {return b>a?a=b,1:0;}
template<typename T> bool remin(T& a, const T& b) {return b<a?a=b,1:0;}
inline ostream& operator << (ostream& os,__int128_t a){if(a==0) {return (os<<'0');}bool flag=0;if(a<0) {a=-a,flag=1;}string s;while(a){s+=a%10+'0';a/=10;}s+=flag?"-":"";reverse(ALL(s));return os<<s;}
inline istream& operator >>(istream& is,__int128_t& a){string s;cin>>s;a=0;for(auto c:s) a=a*__int128_t(10)+__int128_t(c-'0');return is;}
template<typename T,typename P> inline ostream& operator << (ostream& os,pair<T,P> a){os<<a.first<<" "<<a.second; return os;}
template<typename T,typename P> inline istream& operator >> (istream& is,pair<T,P> &a){is>>a.first>>a.second; return is;}
using ll=long long;
using ull=unsigned long long;
using int128= __int128_t;
using uint128= __uint128_t;
using pii =pair<int,int>;
const double pi=acos(-1);
const int N=2E6+5;
const ll M=1000000000;
const ll INF_64=0x3f3f3f3f3f3f3f3f;
const int INF_32=0x3f3f3f3f;
const int16_t INF_16=0x3f3f;
const int klog=20;
const int mod=1E9+7;//998244353
const double eps=1E-8;
void gen(){

}
template <class T>
T qpow(T base,ll power){
    T re=base,tmp=base;
    power--;
    while(power){
        if(power&(1LL)){
            re=re*tmp;re%=mod;
        }
        power>>=1;
        tmp=tmp*tmp;tmp%=mod;
    }
    return re;
}
int pw[N]{};
int invp[N]{};
int val(int n,int m){
    if(n<0||m<0) return 0;
    return pw[n+m]*invp[n]%mod*invp[m]%mod;
}
void sol(){
    pw[0]=1;
    F1(i,N-1) pw[i]=pw[i-1]*i%mod;
    F(i,N) invp[i]=qpow(pw[i],mod-2);
    int n,m,k;cin>>n>>m>>k;
    if(n>m+k){
        cout<<"0\n";
        return;
    }
    int an=val(n,m);
    int sub=val(n-k-1,m+k+1);
    cout<<((an-sub)%mod+mod)%mod<<"\n";
}
int32_t main(){
    #ifdef LOCAL
    //freopen(".in","r",stdin);
    //freopen(".out","w",stdout);
    #endif // LOCAL
    IOS;
    int t=1;
    gen();
    //cin>>t;
    FF(i,1,t+1){
        //cout<<"Case #"<<i<<": ";
        sol();
    }
}

#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>

#include <limits.h>

using namespace std;

typedef long long ll;

template<class T>
inline bool chmax(T &a, T b) {
    if(a < b) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
inline bool chmin(T &a, T b) {
    if(a > b) {
        a = b;
        return true;
    }
    return false;
}

const ll MOD = 998244353;

// auto mod int
// ref. https://github.com/atcoder-live/library/blob/master/mint.cpp
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
struct mint {
  ll x; // typedef long long ll;
  mint(ll x=0):x((x%MOD+MOD)%MOD){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= MOD) x -= MOD;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += MOD-a.x) >= MOD) x -= MOD;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= MOD;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
  mint pow(ll t) const {
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }

  // for prime MOD
  mint inv() const {
    return pow(MOD-2);
  }
  mint& operator/=(const mint a) {
    return (*this) *= a.inv();
  }
  mint operator/(const mint a) const {
    mint res(*this);
    return res/=a;
  }
};

vector<mint> as;

vector<mint> bs;

vector<mint> factorial;

vector<mint> sum_diagonal;

int main(void) {
    int N, K;
    cin >> N >> K;

    as.resize(N);
    for (int i = 0; i < N; i++) {
        int x;
        cin >> x;
        as[i] = mint(x);
    }

    factorial.resize(K + 1);
    factorial[0] = mint(1);
    {
        mint acc = mint(1);
        for (int i = 1; i <= K; i++) {
            acc *= i;
            factorial[i] = acc;
        }
    }

    bs.resize(K + 1);
    {
        for (int i = 0; i < N; i++) {
            mint base = as[i];
            mint acc = mint(1);
            for (int x = 0; x <= K; x++) {
                bs[x] += acc;
                acc *= base;
            }
        }
    }

#ifdef DEBUG
    printf("bs: \n");
    for (int i = 0; i <= K; i++) {
        printf("%lld\n", bs[i].x);
    }
    printf("\n");
#endif

    sum_diagonal.resize(K + 1);
    {
        for (int i = 0; i < N; i++) {
            mint base = as[i] * 2;
            mint acc = mint(1);
            for (int x = 0; x <= K; x++) {
                sum_diagonal[x] += acc;
                acc *= base;
            }
        }
    }

    {
        for (int x = 1; x <= K; x++) {
            mint acc = mint(0);
            for (int y = 0; y <= x; y++) {
                acc += (bs[y] / factorial[y]) * (bs[x - y] / factorial[x - y]);
            }
            acc *= factorial[x];
            acc -= sum_diagonal[x];
            acc /= 2;
            printf("%lld\n", acc.x);
        }
    }

    return 0;
}
