#include <bits/stdc++.h>

using namespace std;
typedef vector<int> poly;

const int N = 5e6 + 10, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
inline int ksm(long long a, int b) {
    long long r = 1;
    for(; b; b >>= 1, a = a * a % MOD)
        if(b & 1) r = r * a % MOD;
    return r;
}

namespace My_poly {
    mt19937 Rand(chrono::steady_clock::now().time_since_epoch().count());
    int rev[N], iv[N];
    inline void make_iv() {
    // 处理 [1, N - 1] 的逆元并存到 iv[] 中
        iv[1] = 1;
        for(int i = 2; i < N; i ++)
            iv[i] = Minus(0, 1ll * iv[MOD % i] * (MOD / i) % MOD);
    }
    inline void make_rev(int n) {
        for(int i = 1; i < n; i ++)
            rev[i] = ((rev[i >> 1] >> 1) | (i & 1) * (n >> 1));
    }
    inline void NTT(poly &A, int type) {
    // 调用前请确保 rev[] 数组的正确
    // type == 1:= DFT
    // type == -1:= IDFT
        static const int g = 3; // 原根
        int n = A.size();
        for(int i = 0; i < n; i ++)
            if(i < rev[i]) swap(A[i], A[rev[i]]);
        for(int h = 2; h <= n; h <<= 1) {
            long long step = ksm(g, (MOD - 1) / h);
            if(type == -1) step = ksm(step, MOD - 2);
            for(int i = 0; i < n; i += h) 
                for(int j = i, mul = 1; j < i + (h >> 1); j ++, mul = mul * step % MOD) {
                    int u = A[j], v = 1ll * A[j + (h >> 1)] * mul % MOD;
                    A[j] = Plus(u, v), A[j + (h >> 1)] = Minus(u, v);
                }
        }
        if(type == -1) {
            long long mul = ksm(n, MOD - 2);
            for(int i = 0; i < n; i ++)
                A[i] = A[i] * mul % MOD;
        }
    }

    poly operator + (const poly &lhs, const poly &rhs) {
        poly res = lhs; res.resize(max(lhs.size(), rhs.size()), 0);
        for(int i = 0; i < rhs.size(); i ++) res[i] = Plus(res[i], rhs[i]);
        return res;
    }
    poly operator - (const poly &lhs, const poly &rhs) {
        poly res = lhs; res.resize(max(lhs.size(), rhs.size()), 0);
        for(int i = 0; i < rhs.size(); i ++) res[i] = Minus(res[i], rhs[i]);
        return res;
    }
    poly operator * (const int lhs, const poly &rhs) {
        poly res = rhs;
        for(int i = 0; i < rhs.size(); i ++)
            res[i] = 1ll * res[i] * lhs % MOD;
        return res;
    }
    poly operator * (const poly &lhs, const int rhs) {
        poly res = lhs;
        for(int i = 0; i < lhs.size(); i ++)
            res[i] = 1ll * res[i] * rhs % MOD;
        return res;
    }
    poly operator * (poly A, poly B) {
        int h = 1;
        while(h <= A.size() + B.size()) h <<= 1;
        A.resize(h, 0), B.resize(h, 0);
        make_rev(h);
        NTT(A, 1), NTT(B, 1);
        for(int i = 0; i < h; i ++) A[i] = 1ll * A[i] * B[i] % MOD;
        NTT(A, -1); return A;
    }
    inline poly derivative(poly A) {
    // 多项式求导
        for(int i = 1; i < A.size(); i ++)
            A[i - 1] = 1ll * i * A[i] % MOD;
        if(!A.empty()) A.pop_back();
        return A;
    }
    inline poly integrate(poly A) {
    // 多项式积分
    // 使用前请保证调用过make_iv函数或init函数
        A.emplace_back(0);
        for(int i = A.size() - 1; i >= 1; i --)
            A[i] = 1ll * A[i - 1] * iv[i] % MOD;
        A[0] = 0;   // 不定积分的常数 C
        return A;
    }
    inline poly inv(poly A, int n) {
    // 多项式求逆
    // 返回模 x^n 意义下 A 的逆元
        int h = 1; while(h < n) h <<= 1; A.resize(h, 0);
        if(A.empty()) return poly();
        poly res(1, ksm(A[0], MOD - 2));
        for(int i = 2; i <= h; i <<= 1) {
            poly q(A.begin(), A.begin() + i);
            res.resize(2 * i, 0), q.resize(2 * i, 0);
            make_rev(2 * i), NTT(res, 1), NTT(q, 1);
            for(int j = 0; j < 2 * i; j ++) res[j] = 1ll * res[j] * Minus(2, 1ll * res[j] * q[j] % MOD) % MOD;
            
            NTT(res, -1); res.resize(i);
        }
        res.resize(n); return res;
    }
    inline poly ln(poly A, int n) {
    // 多项式 ln，返回 ln A 在模 x^n 意义下的结果
    // 调用前请保证 A[0] = 1
        A.resize(n, 0);
        A = derivative(A) * inv(A, n); A.resize(n);
        return integrate(A);
    }
    inline poly exp(poly A, int n) {
    // 多项式 exp，返回exp A 在模 x^n 意义下的结果
    // 调用前请保证 A[0] = 0
        if(n == 1) return poly(1, 1);
        int t = (n + 1) >> 1;
        poly res = exp(poly(A.begin(), A.begin() + t), t);
        res = res * (poly(1, 1) - ln(res, n) + A);
        res.resize(n); return res;
    }
    inline poly power(poly A, int k, int n) {
    // 多项式快速幂，返回 A^k 在模 x^n 意义下的结果
    // 不要求 A[0] = 1
        int p = -1; A.resize(n, 0);
        for(int i = 0; i < n; i ++)
            if(A[i] != 0) {p = i; break; }
        if(p == -1) return A;   // A = 0
        long long val = ksm(A[p], k), mul = ksm(A[p], MOD - 2);
        for(int i = p; i < n; i ++) A[i - p] = A[i] * mul % MOD;
        for(int i = n - p; i < n; i ++) A[i] = 0;
        A = exp(k * ln(A, n), n);
        p = min(1ll * p * k, 1ll * n);
        for(int i = p; i < n; i ++) A[i] = A[i - p] * val % MOD;
        for(int i = 0; i < p; i ++) A[i] = 0;
        return A;
    }
    inline poly power(poly A, string k, int n) {
    // 多项式快速幂，返回 A^k 在模 x^n 意义下的结果
    // 不要求 A[0] = 1
        long long mod1 = 0, mod2 = 0;
        bool zero = false;  // 答案是否为 0
        int p = -1; A.resize(n, 0);
        for(int i = 0; i < n; i ++)
            if(A[i] != 0) {p = i; break; }
        if(p == -1) return A;   // A = 0
        for(int i = 0; i < k.size(); i ++) {
            if((mod1 * 10 + (k[i] - '0')) * p >= n) {zero = true; break; }
            mod1 = (mod1 * 10 + (k[i] - '0')) % MOD;
            mod2 = (mod2 * 10 + (k[i] - '0')) % (MOD - 1);  // 指数对 \varphi(MOD) 取模
        }
        if(zero) return poly(n, 0);
        long long val = ksm(A[p], mod2), mul = ksm(A[p], MOD - 2);
        for(int i = p; i < n; i ++) A[i - p] = A[i] * mul % MOD;
        for(int i = n - p; i < n; i ++) A[i] = 0;
        A = exp(mod1 * ln(A, n), n);
        p = p * mod1;
        for(int i = n - 1; i >= p; i --) A[i] = A[i - p] * val % MOD;
        for(int i = 0; i < p; i ++) A[i] = 0;
        return A;
    }
    inline poly sqrt1(poly A, int n) {
    // 多项式开根，返回 \sqrt{A} 在模 x^n 意义下的结果
    // 调用时请保证 A[0] = 1，可以稍加修改得到 A[0] 为完全平方数时的算法
        int h = 1; while(h < n) h <<= 1;
        A.resize(h, 0); poly res(1, 1);
        for(int i = 2; i <= h; i <<= 1) {
            res = (res * res + poly(A.begin(), A.begin() + i)) * inv(2 * res, i);
            res.resize(i);
        }
        res.resize(n); return res;
    }

    // 二次剩余相关
    long long w;
    struct Complex {
        int x, y;
        Complex(int _x = 0, int _y = 0): x(_x), y(_y) {}
    };
    Complex operator * (const Complex &lhs, const Complex &rhs) 
        {return Complex(Plus(1ll * lhs.x * rhs.x % MOD, 1ll * lhs.y * rhs.y % MOD * w % MOD), 
            Plus(1ll * lhs.x * rhs.y % MOD, 1ll * lhs.y * rhs.x % MOD)); }
    inline Complex complex_ksm(Complex A, int b) {
        Complex r(1, 0);
        for(; b; b >>= 1, A = A * A)
            if(b & 1) r = r * A;
        return r;
    }
    long long Cipolla(long long x) {
        if (ksm(x,(MOD - 1) >> 1) == MOD - 1) return -1;
        while(true) {
            long long a = Rand() % MOD;
            w = (a * a % MOD + MOD - x) % MOD;
            if(ksm(w,(MOD - 1) >> 1) == MOD - 1) {
                int res = complex_ksm(Complex(a, 1), (MOD + 1) >> 1).x;
                return std::min(res, MOD - res); // 选用首项较小的解
            }
        }
    }

    inline poly sqrt(poly A, int n) {
    // 多项式开根，返回 \sqrt{A} 在模 x^n 意义下的结果
    // 调用时不需要保证 A[0] = 1
        if(A.empty()) return A;
        A.resize(n, 0);
        long long val = A[0], mul = ksm(A[0], MOD - 2);
        for(int i = 0; i < n; i ++) A[i] = A[i] * mul % MOD;
        A = sqrt1(A, n);
        val = Cipolla(val);
        for(int i = 0; i < n; i ++) A[i] = A[i] * val % MOD;
        return A;
    }

    inline void Rev(poly &A) {
    // 反转系数
        int n = (int)A.size() - 1;
        for(int i = 0; 2 * i < n; i ++)
            swap(A[i], A[n - i]);
    }
    inline pair<poly, poly> Div(poly A, poly B) {
    // 多项式除法，返回的 std::pair 中第一维是商，第二维是余数
        while(!A.empty() && A.back() == 0) A.pop_back();
        while(!B.empty() && B.back() == 0) B.pop_back();
        if(A.size() < B.size()) return {poly(1, 0), A};
        int n = (int)A.size() - 1, m = (int)B.size() - 1;
        Rev(A), Rev(B); poly p = A * inv(B, n - m + 1); p.resize(n - m + 1, 0);
        Rev(A), Rev(B), Rev(p); poly r = A - B * p; r.resize(m, 0);
        return {p, r};
    }
    inline void init() {make_iv(); }
} // namespace My_poly
using namespace My_poly;

int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    init(); // poly 初始化

    int n; cin >> n; poly f(n);
    for(int i = 0; i < n; i ++) cin >> f[i];
    f = exp(f, n);
    for(int i = 0; i < n; i ++)
        cout << f[i] << " \n"[i == n - 1];

    return 0;
}