#include <bits/stdc++.h>

using namespace std;

#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

const int mod = 998244353;
const int g = 3;

inline void uadd(int &a, int b) { a += b - mod; a += (a >> 31) & mod; }
inline void usub(int &a, int b) { a -= b; a += (a >> 31) & mod; }
inline void umul(int &a, int b) { a = 1LL * a * b % mod; }

int add(int a, int b) { uadd(a, b); return a; }
int sub(int a, int b) { usub(a, b); return a; }
int mul(int a, int b) { umul(a, b); return a; }

int qp(int x, long long y = mod - 2) {
	int ret = 1;
	for (; y; y >>= 1, umul(x, x)) if (y & 1) umul(ret, x);
	return ret;
}

int r[1 << 20], w[1 << 20];

void fft_init(int n) {
	int k = 0; while((1 << k) < n) ++k;
	rep(i, n - 1) if (i) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (k - 1));
	for (int h = 1; h < n; h <<= 1) {
		int x = qp(g, (mod - 1) / (h << 1));
		rep(i, h) w[h + i] = i ? mul(x, w[h + i - 1]) : 1;
	}
}

void fft(int *a, int n, bool f = 0) {
	rep(i, n - 1) if (i && i < r[i]) swap(a[i], a[r[i]]);
	for (int h = 1; h < n; h <<= 1) {
		for (int i = 0; i < n; i += h << 1) {
			rep(j, h) {
				int v = mul(a[i + h + j], w[h + j]);
				a[i + h + j] = sub(a[i + j], v);
				uadd(a[i + j], v);
			}
		}
	}
	if (f) {
		reverse(a + 1, a + n);
		int inv = qp(n);
		rep(i, n) umul(a[i], inv);
	}
}


struct Poly: vector<int> {
public:
	Poly(int n, int x = 0) {
		clear();
		resize(n, x);
	}
	Poly modn(int n) const {
		Poly ans(*this);
		ans.resize(n);
		return ans;
	}
	
	Poly operator + (const Poly &o) const {
		Poly ans(max(size(), o.size()));
		rep(i, size()) uadd(ans[i], at(i));
		rep(i, o.size()) uadd(ans[i], o.at(i));
		return ans;
	}
	
	Poly operator - (const Poly &o) const {
		Poly ans(max(size(), o.size()));
		rep(i, size()) uadd(ans[i], at(i));
		rep(i, o.size()) usub(ans[i], o.at(i));
		return ans;
	}
	
	Poly operator * (int c) const {
		Poly ans(size());
		rep(i, size()) ans[i] = mul(at(i), c);
		return ans;
	}
	
	Poly operator * (const Poly &o) const {
		static int A[1 << 20], B[1 << 20];
		int n = size() + o.size() - 1;
		Poly ans(n);
		if (false && min(size(), o.size()) <= 32) {
			rep(i, size()) rep(j, o.size())
				uadd(ans[i + j], mul(at(i), o.at(j)));
			return ans;
		}
		int sz = 1; for (; sz < n; sz <<= 1);
		fft_init(sz);
		memset(A, 0, sz << 2);
		memset(B, 0, sz << 2);
		rep(i, size()) A[i] = at(i);
		rep(i, o.size()) B[i] = o.at(i);
		fft(A, sz);
		fft(B, sz);
		rep(i, sz) umul(A[i], B[i]);
		fft(A, sz, 1);
		rep(i, n) ans[i] = A[i];
		return ans;
	}
	
	Poly deriv() const {
		Poly ans(size() - 1);
		rep(i, size() - 1) ans[i] = mul(i + 1, at(i + 1));
		return ans;
	}
	
	Poly inte() const {
		Poly ans(size() + 1);
		rep(i, size()) ans[i + 1] = mul(qp(i + 1), at(i));
		return ans;
	}
	
	Poly inv() const {
		if (size() == 1) {
			Poly ans(1);
			ans[0] = qp(at(0));
			return ans;
		}
		int n = size(), n0 = (n + 1) >> 1;
		Poly h = *this, h0 = h.modn(n0), f0 = h0.inv().modn(n);
		return (f0 * 2 - f0 * f0 * h).modn(n);
	}
	
	Poly ln() const {
		assert(at(0) == 1);
		return (deriv() * inv()).inte().modn(size());
	}
	
	Poly exp() const {
		if (size() == 1) {
			Poly ans(1);
			assert(at(0) == 0);
			ans[0] = 1;
			return ans;
		}
		int n = size(), n0 = (n + 1) >> 1;
		Poly h = *this, h0 = h.modn(n0), f0 = h0.exp().modn(n);
		return (f0 * (Poly(1, 1) + h - f0.ln())).modn(n); 
	}
	
	Poly pow(int k) const {
		return (ln() * k).exp();
	}
} ;

const int maxn = 1e5 + 5;

int n, K;
int a[5];
int fac[maxn], ifac[maxn];

int main(){
	scanf("%d%d", &n, &K);
	for (int i = 0; i <= K; ++i) scanf("%d", a + i);
	if (K == 0) {
		for (int i = 2; i <= n; ++i) printf("%d ", qp(a[0], 1ll * i * (i - 1) / 2));
		puts("");
		return 0;
	}
	
	fac[0] = 1; for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
	ifac[n] = qp(fac[n]); for (int i = n - 1; ~i; --i) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
	
	int v1 = 1ll * a[1] * qp(a[0]) % mod;

	Poly tree(n + 1);
	for (int i = 1; i <= n; ++i) {
		tree[i] = 1ll * (i == 1 ? 1 : qp(i, i - 2)) * ifac[i] % mod * qp(v1, 1ll * i * (i - 1) / 2) % mod;
	}
	if (K == 1) {
		Poly trees = tree.exp();
		
		for (int i = 2; i <= n; ++i) {
			int res = 1ll * fac[i] * trees[i] % mod * qp(a[0], 1ll * i * (i - 1) / 2) % mod;
			printf("%d ", res);
		}
		puts("");
		return 0;
	}
	
	int v2 = 1ll * a[1] * qp(a[2]) % mod;
	Poly rooted(n + 1);
	for (int i = 1; i <= n; ++i) {
		rooted[i] = 1ll * qp(i, i - 1) * ifac[i] % mod * qp(v2, 1ll * i * (i - 1) / 2) % mod;
	}
	Poly cycle_based = (Poly(1, 1) - rooted).ln() * (-1);
	cycle_based = cycle_based - rooted;
	cycle_based = cycle_based - rooted * rooted * qp(2);
	cycle_based = cycle_based * qp(2);
	
	int v3 = 1ll * a[2] * qp(a[0]) % mod;
	for (int i = 1; i <= n; ++i) {
		cycle_based[i] = 1ll * cycle_based[i] * qp(v3, 1ll * i * (i - 1) / 2) % mod;
	}

	Poly connected = tree + cycle_based;
	
	Poly graph = connected.exp();
	for (int i = 2; i <= n; ++i) {
		int res = 1ll * graph[i] * fac[i] % mod * qp(a[0], 1ll * i * (i - 1) / 2) % mod;
		printf("%d ", res);
	}
	puts("");
	return 0;
}