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

constexpr int mod = 998244353, N = 1 << 22, invg = (mod + 1) / 3;
namespace basic {
  inline int add(int x, int y) {return (x + y >= mod ? x + y - mod : x + y);}
  inline int dec(int x, int y) {return (x - y < 0 ? x - y + mod : x - y);}
  inline void ad(int &x, int y) {x = add(x, y);}
  inline void de(int &x, int y) {x = dec(x, y);}

  inline int qpow(int a, int b) {
    int r = 1;
    while(b) {
      if(b & 1) r = 1ll * r * a % mod;
      a = 1ll * a * a % mod; b >>= 1;
    }
    return r;
  }
  inline int inv(int x) {return qpow(x, mod - 2);}

  int fac[N], ifac[N];
  inline void fac_init(int n = N - 1) {
    fac[0] = 1;
    for(int i = 1; i <= n; i++)
      fac[i] = 1ll * fac[i - 1] * i % mod;
    ifac[n] = inv(fac[n]);
    for(int i = n - 1; i >= 0; i--)
      ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
  }
  int invx[N];
  inline void inv_init(int n = N - 1) {
    invx[1] = 1;
    for(int i = 2; i <= n; i++)
      invx[i] = 1ll * (mod - mod / i) * invx[mod % i] % mod;
  }
  inline int binom(int n, int m) {
    if(n < m || m < 0) return 0;
    return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
  }
  int rev[N];
  inline void rev_init(int n) {
    for(int i = 1; i < n; i++) {
      rev[i] = (rev[i >> 1] >> 1) | (i & 1 ? n >> 1 : 0);
    }
  }
}
using namespace basic;

struct Poly {
  vector<int> a;
  inline int size() {return a.size();}
  inline void resize(int n) {a.resize(n, 0);}
  inline int& operator [] (int x) {return a[x];}

  Poly() {}
  explicit Poly(int n) {a.resize(n);}
  Poly(const vector<int> b) {a = b;}

  inline void NTT(int type) {
    int n = size(); rev_init(n);
    for(int i = 1; i < n; i++) if(i < rev[i]) swap(a[i], a[rev[i]]);
    static int gr[N]; gr[0] = 1;
    for(int d = 1; d < n; d <<= 1) {
      int gw = qpow(type == 1 ? 3 : invg, (mod - 1) / (d << 1));
      for(int i = 1; i < d; i++) {
        gr[i] = 1ll * gr[i - 1] * gw % mod;
      }
      for(int i = 0; i < n; i += d << 1) {
        for(int j = 0; j < d; j++) {
          int x = a[i + j], y = 1ll * gr[j] * a[i + j + d] % mod;
          a[i + j] = add(x, y);
          a[i + j + d] = dec(x, y);
        }
      }
    }
    if(type == -1) {
      for(int i = 0, invn = inv(n); i < n; i++) {
        a[i] = 1ll * invn * a[i] % mod;
      }
    }
  }
  inline friend Poly operator * (Poly A, Poly B) {
    int n = A.size() + B.size() - 1;
    int m = 1; while(m < n) m <<= 1;
    A.resize(m), B.resize(m);
    A.NTT(1), B.NTT(1);
    for(int i = 0; i < m; i++) {
      A[i] = 1ll * A[i] * B[i] % mod;
    }
    A.NTT(-1); A.resize(n);
    return A;
  }

  inline friend Poly operator + (Poly A, Poly B) {
    Poly C(max(A.size(), B.size()));
    for(int i = 0; i < C.size(); i++) {
      if(i < A.size()) ad(C[i], A[i]);
      if(i < B.size()) ad(C[i], B[i]);
    }
    return C;
  }
  inline friend Poly operator - (Poly A, Poly B) {
    Poly C(max(A.size(), B.size()));
    for(int i = 0; i < C.size(); i++) {
      if(i < A.size()) ad(C[i], A[i]);
      if(i < B.size()) de(C[i], B[i]);
    }
    return C;
  }

  inline Poly Inv() {
    Poly g = vector<int>{inv(a[0])};
    while(g.size() < size()) {
      int n = g.size() << 1; 
      int m = n << 1;
      g.resize(m); g.NTT(1);
      Poly h = *this; h.resize(m); h.NTT(1);
      for(int i = 0; i < m; i++) {
        g[i] = 1ll * g[i] * dec(2, 1ll * g[i] * h[i] % mod) % mod;
      }
      g.NTT(-1), g.resize(n);
      // h = g * h; h.resize(n);
      // g = g * (vector<int>{2} - h); g.resize(n);
    }
    g.resize(size());
    return g;
  }

  inline Poly Deriv() {
    if(!size()) return Poly();
    int n = size();
    Poly C(n - 1);
    for(int i = 0; i < n - 1; i++) {
      C[i] = 1ll * (i + 1) * a[i + 1] % mod;
    }
    return C;
  }
  inline Poly Integ() {
    int n = size(); inv_init(n); 
    Poly C(n + 1);
    for(int i = 1; i <= n; i++) {
      C[i] = 1ll * invx[i] * a[i - 1] % mod;
    }
    return C;
  }
  inline Poly Ln() {
    assert(a[0] == 1);
    Poly g = ((*this).Deriv() * (*this).Inv()).Integ();
    g.resize(size());
    return g;
  }

  inline Poly Exp() {
    Poly g = vector<int>{1};
    while(g.size() < size()) {
      int n = g.size() << 1; g.resize(n);
      Poly h = *this; h.resize(n);
      g = g * (vector<int>{1} - g.Ln() + h);
      g.resize(n);
    }
    g.resize(size());
    return g;
  }
};

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr), cout.tie(nullptr);
  
  int n; cin >> n;
  Poly A(n);
  for(int i = 0; i < n; i++) {
    cin >> A[i];
  }
  A = A.Exp();
  for(int i = 0; i < n; i++) {
    cout << A[i] << " \n"[i == n - 1];
  }
}