#include <bits/stdc++.h>
#include <atcoder/convolution>
using namespace std;
using ll = long long;
const int MOD = 998244353;

int addmod(int a, int b){ a += b; if (a >= MOD) a -= MOD; return a; }
int submod(int a, int b){ a -= b; if (a < 0) a += MOD; return a; }
int mulmod(ll a, ll b){ return int((a*b) % MOD); }

int modpow(int a, ll e){
    ll r = 1, x = a;
    while (e){
        if (e & 1) r = (r * x) % MOD;
        x = (x * x) % MOD;
        e >>= 1;
    }
    return int(r);
}

int N, M;
vector<int> V; 
vector<int> build_B(int l, int r){
    if (l == r){
        vector<int> p(2);
        p[0] = 1;
        p[1] = (MOD - V[l]) % MOD;
        if ((int)p.size() > M+1) p.resize(M+1);
        return p;
    }
    int mid = (l + r) >> 1;
    auto L = build_B(l, mid);
    auto R = build_B(mid+1, r);
    auto conv = atcoder::convolution(L, R);
    if ((int)conv.size() > M+1) conv.resize(M+1);
    return conv;
}

vector<int> trunc_poly(const vector<int>& a, int m){
    int sz = min((int)a.size(), m);
    vector<int> r(m);
    for (int i = 0; i < sz; ++i) r[i] = a[i];
    for (int i = sz; i < m; ++i) r[i] = 0;
    return r;
}

vector<int> mul_trunc(const vector<int>& a, const vector<int>& b, int m){
    auto conv = atcoder::convolution(a, b);
    if ((int)conv.size() > m) conv.resize(m);
    else conv.resize(m);
    return conv;
}

vector<int> poly_inv(const vector<int>& A, int m){
    vector<int> R(1, modpow(A[0], MOD-2));
    int cur = 1;
    while (cur < m){
        cur <<= 1;
        auto AR = mul_trunc(A, R, cur);
        for (int i = 0; i < cur; ++i){
            AR[i] = (i < (int)AR.size() ? AR[i] : 0);
            AR[i] = ( (i==0 ? 2 : 0) - AR[i] ) % MOD;
            if (AR[i] < 0) AR[i] += MOD;
        }
        R = mul_trunc(R, AR, cur);
    }
    R.resize(m);
    return R;
}

vector<int> poly_derivative(const vector<int>& A){
    int n = (int)A.size();
    if (n <= 1) return vector<int>{0};
    vector<int> D(n-1);
    for (int i = 1; i < n; ++i){
        D[i-1] = mulmod(A[i], i);
    }
    return D;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    cin >> N >> M;
    
    V.resize(N);
    for (int i = 0; i < N; ++i){
        long long x; cin >> x;
        x %= MOD;
        if (x < 0) x += MOD;
        V[i] = (int)x;
    }

    vector<int> B = build_B(0, N-1);
    if ((int)B.size() < M+1) B.resize(M+1, 0);

    auto Bder = poly_derivative(B); 
    vector<int> A_for_inv = B;
    A_for_inv.resize(M);
    vector<int> invB = poly_inv(A_for_inv, M);

    auto E = mul_trunc(Bder, invB, M); 
    vector<int> S(M+1);
    for (int k = 1; k <= M; ++k){
        int coeff = 0;
        if (k-1 < (int)E.size()) coeff = E[k-1];
        coeff = (MOD - coeff) % MOD;
        S[k] = coeff;
    }

    vector<int> mu(M+1, 0), isp(M+1, 1), primes;
    mu[0] = 0; if (M>=1) mu[1] = 1;
    isp.assign(M+1,1);
    if (M>=0) isp[0]=0;
    if (M>=1) isp[1]=0;
    for (int i = 2; i <= M; ++i){
        if (isp[i]) { primes.push_back(i); mu[i] = -1; }
        for (int p : primes){
            long long j = 1LL * p * i;
            if (j > M) break;
            isp[j] = 0;
            if (i % p == 0){ mu[j] = 0; break; }
            else mu[j] = -mu[i];
        }
    }

    vector<vector<int>> divs(M+1);
    for (int d = 1; d <= M; ++d){
        for (int j = d; j <= M; j += d) divs[j].push_back(d);
    }

    vector<int> ans(M+1, 0);
    for (int l = 1; l <= M; ++l){
        long long res = 0;
        for (int e : divs[l]){
            int k = l / e;
            int muk = mu[k];
            if (muk == 0) continue;
            int base = S[k];
            if (base == 0) continue;
            int term = modpow(base, e);
            if (muk == 1) res += term;
            else res -= term;
            res %= MOD;
        }
        res %= MOD; if (res < 0) res += MOD;
        ans[l] = int(res);
    }

    for (int i = 1; i <= M; ++i){
        if (i > 1) cout << ' ';
        cout << ans[i];
    }

    return 0;
}