#include <bits/stdc++.h>
using namespace std;

namespace {

const int mod = 998244353;
const int G = 3;
const int maxn = 1 << 20;

int modadd(int a, int b) {
    return a + b >= mod ? a + b - mod : a + b;
}
int modsub(int a, int b) {
    return a - b < 0 ? a - b + mod : a - b;
}
int modmul(int64_t a, int64_t b) {
    return static_cast<int>(a * b % mod);
}
int modpow(int e, int64_t p) {
    int r = 1;
    while (p) {
        if (p & 1) r = modmul(r, e);
        e = modmul(e, e);
        p >>= 1;
    }
    return r;
}
int modinv(int x) {
    return modpow(x, mod - 2);
}

struct NTT {
    static_assert (maxn == (maxn & -maxn));
    int roots[maxn];
    NTT() {
        int r = modpow(G, (mod - 1) / maxn);
        for (int i = maxn >> 1; i; i >>= 1) {
            roots[i] = 1;
            for (int j = 1; j < i; j++)
                roots[i + j] = modmul(roots[i + j - 1], r);
            r = modmul(r, r);
        }
    }
    void operator()(int F[], int n, bool inv = false) {
        for (int i = 0, j = 0; i < n; i++) {
            if (i < j) swap(F[i], F[j]);
            for (int k = n >> 1; (j ^= k) < k; k >>= 1)
                ;
        }
        for (int s = 1; s < n; s *= 2) {
            for (int i = 0; i < n; i += s * 2) {
                for (int j = 0; j < s; j++) {
                    int a = F[i + j];
                    int b = modmul(F[i + j + s], roots[s + j]);
                    F[i + j] = modadd(a, b);
                    F[i + j + s] = modsub(a, b);
                }
            }
        }
        if (inv) {
            int invn = modinv(n);
            for (int i = 0; i < n; i++)
                F[i] = modmul(F[i], invn);
            reverse(F + 1, F + n);
        }
    }
};

NTT ntt;

using V = vector<int>;
#define fi(l, r) for (int i = int(l); i < int(r); ++i)
struct Poly : V {
    static uint32_t n2k(uint32_t n) {
        if (n <= 1) return 1;
        return 1u << (32 - __builtin_clz(n - 1));
    }
    explicit Poly(int n = 1) : V(n) {}
    Poly (const V &v) : V(v) {}
    Poly(const Poly &p, size_t n) : V(n) {
        copy_n(p.data(), min(p.size(), n), data());
    }
    Poly &isz(int sz) { return resize(sz), *this; }
    Poly &iadd(const Poly &rhs) {
        fi(0, size()) (*this)[i] = modadd((*this)[i], rhs[i]);
        return *this;
    }
    Poly &imul(int k) {
        fi(0, size()) (*this)[i] = modmul((*this)[i], k);
        return *this;
    }

    Poly Mul(const Poly &rhs) const {
        const int sz = n2k(size() + rhs.size() - 1);
        Poly X(*this, sz), Y(rhs, sz);
        ntt(X.data(), sz), ntt(Y.data(), sz);
        fi(0, sz) X[i] = modmul(X[i], Y[i]);
        ntt(X.data(), sz, true);
        return X.isz(size() + rhs.size() - 1);
    }
    Poly Inv() const {
        if (size() == 1) return V{modinv(*begin())};
        const int sz = n2k(size() * 2);
        Poly X = Poly(*this, (size() + 1) / 2).Inv().isz(sz),
             Y(*this, sz);
        ntt(X.data(), sz);
        ntt(Y.data(), sz);
        fi(0, sz) X[i] = modmul(X[i], modsub(2, modmul(X[i], Y[i])));
        ntt(X.data(), sz, true);
        return X.isz(size());
    }
    Poly Dx() const {
        Poly ret(size() - 1);
        fi(0, ret.size()) ret[i] = modmul(i + 1, (*this)[i + 1]);
        return ret.isz(max<int>(1, ret.size()));
    }
    Poly Sx() const {
        Poly ret(size() + 1);
        fi(0, size()) ret[i + 1] = modmul(modinv(i + 1), (*this)[i]);
        // TODO
        return ret;
    }


    Poly Ln() const {
        return Dx().Mul(Inv()).Sx().isz(size());
    }
    Poly Exp() const {
        if (size() == 1) return V{1};
        Poly X = Poly(*this, (size() + 1) / 2).Exp().isz(size());
        Poly Y = X.Ln();
        Y[0] = mod - 1;
        fi(0, size()) Y[i] = modsub((*this)[i], Y[i]);
        return X.Mul(Y).isz(size());
    }
};

}

void PRINT(Poly &p) {
    cerr << "PRINT =======" << endl;
    for (int i = 0; i < p.size(); i++) {
        cerr << p[i] << ", ";
    }
    cerr << endl;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int n, k;
    cin >> n >> k;
    int A[10];
    for (int i = 0; i <= k; i++)
        cin >> A[i];
    if (k == 3) {
        k = 2;
    }

    if (k == 0) {
        for (int i = 2; i <= n; i++) {
            cout << modpow(A[0], 1LL*i*(i-1)/2) << (i==n ? '\n' : ' ');
        }
        return 0;
    }

    A[1] = modmul(A[1], modinv(A[0]));
    A[2] = modmul(A[2], modinv(A[0]));

    Poly F(n + 1);
    // PRINT(F);
    for (int i = 1; i <= n; i++) {
        F[i] = modmul(modpow(i, max(0, i - 2)), modpow(A[1], 1LL*i*(i-1)/2));
    }
    // cerr << "here" << endl;

    vector<int> fac(n + 1), ifac(n + 1);
    fac[0] = 1;
    for (int i = 1; i <= n; i++)
        fac[i] = modmul(fac[i-1], i);
    for (int i = 0; i <= n; i++)
        ifac[i] = modinv(fac[i]);

    if (k == 2) {
        Poly H(n + 1);
        {
            const int rt = modmul(A[1], modinv(A[2]));
            for (int i = 1; i <= n; i++) {
                H[i] = modmul(modpow(i, max(0, i - 1)), modpow(rt, 1LL*i*(i-1)/2));
            }
        }
        for (int i = 1; i <= n; i++) {
            H[i] = modmul(H[i], ifac[i]);
        }

        Poly G = H;
        for (int i = 1; i <= n; i++) {
            G[i] = modsub(0, G[i]);
        }
        G[0] = 1;
        
        G = G.Ln();

        for (int i = 1; i <= n; i++)
            G[i] = modsub(0, G[i]);

        Poly H2 = H.Mul(H).imul(modinv(2));

        for (int i = 0; i <= n; i++) {
            G[i] = modsub(G[i], modadd(H[i], H2[i]));
            G[i] = modmul(G[i], modpow(A[2], 1LL*i*(i-1)/2));
        }

        for (int i = 0; i <= n; i++)
            G[i] = modmul(G[i], fac[i]);

        int inv2 = modinv(2);
        for (int i = 0; i <= n; i++)
            G[i] = modmul(G[i], inv2);

        for (int i = 0; i <= n; i++) {
            F[i] = modadd(F[i], G[i]);
        }
    }

    for (int i = 0; i <= n; i++) {
        F[i] = modmul(F[i], ifac[i]);
    }

    // PRINT(F);
    F = F.Exp();
    // PRINT(F);
    for (int i = 2; i <= n; i++) {
        int P = modpow(A[0], 1LL*i*(i-1)/2);
        cout << modmul(P, modmul(fac[i], F[i])) << (i==n ? '\n' : ' ');
    }

    return 0;
}