#include <bits/stdc++.h>
using namespace std;
namespace Wilson_Inversion {
    void main();
}
int main() {
    return Wilson_Inversion::main(), 0;
}
namespace Wilson_Inversion {

typedef long long i64;

#define int long long

const int mod = 998244353;

int n, c, a[40], dp[2][310][40][310][2], fac[310], inv[310], ifac[310], pw[310], npw[310], mg[310];

void add(int& x, int y) {
    x += y;
    if (x >= mod) x -= mod;
}

int qp(int x, int y) {
    int res = 1;
    while (y) {
        if (y & 1) (res *= x) %= mod;
        (x *= x) %= mod;
        y >>= 1;
    }
    return res;
}

void solve() {
    cin >> n >> c;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    fac[0] = fac[1] = ifac[0] = ifac[1] = inv[1] = 1;
    pw[0] = npw[0] = 1;
    mg[0] = 1;
    for (int i = 2; i <= 300; ++i) {
        fac[i] = fac[i - 1] * i % mod;
        inv[i] = (mod - mod / i) * inv[mod % i] % mod;
        ifac[i] = ifac[i - 1] * inv[i] % mod;
    }
    for (int i = 1; i <= 300; ++i) pw[i] = pw[i - 1] * n % mod, npw[i] = npw[i - 1] * inv[n] % mod, mg[i] = npw[i] * ifac[i] % mod;
    int t = 0;
    for (int i = 1; i <= c; ++i) t += a[i];
    for (int i = 1; i < t; ++i) cout << "0 ";
    int tot = 0;
    for (int i = 1; i <= n; ++i) tot += a[i];
    bool op = 0;
    dp[0][0][0][0][0] = 1;
    int ts = 0;
    for (int i = 1; i <= c; ++i) {
        op ^= 1;
        memset(dp[op], 0, sizeof(dp[op]));
        for (int j = ts; j <= ts; ++j) {
            for (int k = 0; k < i; ++k) {
                for(int l = 0; l <= tot; ++l) {
                    if (dp[op^1][j][k][l][0]) {
                        add(dp[op][j+a[i]][k+1][l][0], dp[op^1][j][k][l][0]);
                        for (int m = 0; m < a[i]; ++m) add(dp[op][j+a[i]][k][l+m][0], (mod - dp[op^1][j][k][l][0] * mg[m] % mod) % mod);
                        add(dp[op][j+a[i]][k][l+a[i]-1][1], dp[op^1][j][k][l][0] * mg[a[i]-1] % mod);
                    }
                    if (dp[op^1][j][k][l][1]) {
                        add(dp[op][j+a[i]][k+1][l][1], dp[op^1][j][k][l][1]);
                        for (int m = 0; m < a[i]; ++m) add(dp[op][j+a[i]][k][l+m][1], (mod - dp[op^1][j][k][l][1] * mg[m] % mod) % mod);
                    }
                }
            }
        }
        ts += a[i];
    }
    for (int i = c + 1; i <= n; ++i) {
        op ^= 1;
        memset(dp[op], 0, sizeof(dp[op]));
        for (int j = 0; j < a[i]; ++j) {
            for (int k = 0; k <= ts; ++k) {
                for (int l = 0; l < i; ++l) {
                    for (int m = 0; m <= tot; ++m) {
                        if (dp[op^1][k][l][m][0]) {
                            add(dp[op][k+j][l][m+j][0], dp[op^1][k][l][m][0] * mg[j] % mod);
                            if (j > 0) add(dp[op][k+j][l][m+j-1][1], dp[op^1][k][l][m][0] * mg[j-1] % mod);
                        }
                        if (dp[op^1][k][l][m][1]) add(dp[op][k+j][l][m+j][1], dp[op^1][k][l][m][1] * mg[j] % mod);
                    }
                }
            }
        }
        for (int j = 0; j <= ts; ++j) {
            for (int k = 0; k < i; ++k) {
                for(int l = 0; l <= tot; ++l) {
                    if (dp[op^1][j][k][l][0]) {
                        add(dp[op][j+a[i]][k+1][l][0], dp[op^1][j][k][l][0]);
                        for (int m = 0; m < a[i]; ++m) add(dp[op][j+a[i]][k][l+m][0], (mod - dp[op^1][j][k][l][0] * mg[m] % mod) % mod);
                        add(dp[op][j+a[i]][k][l+a[i]-1][1], dp[op^1][j][k][l][0] * mg[a[i]-1] % mod);
                    }
                    if (dp[op^1][j][k][l][1]) {
                        add(dp[op][j+a[i]][k+1][l][1], dp[op^1][j][k][l][1]);
                        for (int m = 0; m < a[i]; ++m) add(dp[op][j+a[i]][k][l+m][1], (mod - dp[op^1][j][k][l][1] * mg[m] % mod) % mod);
                    }
                }
            }
        }
        ts += a[i];
    }
    for (int i = t; i <= tot; ++i) {
        int ans = 0;
        for (int j = 0; j <= n; ++j) {
            for (int k = 0; k <= tot; ++k) {
                (ans += (dp[op][i][j][k][1] * qp(qp(mod + 1 - j * inv[n] % mod, mod - 2), k + 1)) % mod * fac[k]) %= mod;
            }
        }
        cout << ans * inv[n] % mod << ' ';
    }
}

void main() {
    ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int T = 1;
    // cin >> T;
    while (T--) solve();
}

}