#include using i32 = std::int32_t; using u32 = std::uint32_t; using i64 = std::int64_t; using u64 = std::uint64_t; using i128 = __int128_t; using u128 = __uint128_t; using isize = std::ptrdiff_t; using usize = std::size_t; class rep { struct Iter { usize itr; constexpr Iter(const usize pos) noexcept : itr(pos) {} constexpr void operator++() noexcept { ++itr; } constexpr bool operator!=(const Iter& other) const noexcept { return itr != other.itr; } constexpr usize operator*() const noexcept { return itr; } }; const Iter first, last; public: explicit constexpr rep(const usize first, const usize last) noexcept : first(first), last(std::max(first, last)) {} constexpr Iter begin() const noexcept { return first; } constexpr Iter end() const noexcept { return last; } }; template constexpr T totient(T x) { T ret = x; for (T i = 2; i * i <= x; ++i) { if (x % i == 0) { ret /= i; ret *= i - 1; while (x % i == 0) x /= i; } } if (x > 1) { ret /= x; ret *= x - 1; } return ret; } template constexpr T rem_euclid(T value, const T& mod) { return (value %= mod) >= 0 ? value : value + mod; } template * = nullptr> class StaticModint { using Mint = StaticModint; static inline constexpr u32 PHI = totient(MOD); u32 v; public: static constexpr u32 mod() noexcept { return MOD; } template and std::is_integral_v>* = nullptr> static constexpr T normalize(const T x) noexcept { return rem_euclid>(x, MOD); } template and std::is_integral_v>* = nullptr> static constexpr T normalize(const T x) noexcept { return x % MOD; } constexpr StaticModint() noexcept : v(0) {} template constexpr StaticModint(const T x) noexcept : v(normalize(x)) {} template static constexpr Mint raw(const T x) noexcept { Mint ret; ret.v = x; return ret; } constexpr u32 get() const noexcept { return v; } constexpr Mint neg() const noexcept { return raw(v == 0 ? 0 : MOD - v); } constexpr Mint inv() const noexcept { return pow(PHI - 1); } constexpr Mint pow(u64 exp) const noexcept { Mint ret(1), mult(*this); for (; exp > 0; exp >>= 1) { if (exp & 1) ret *= mult; mult *= mult; } return ret; } constexpr Mint operator-() const noexcept { return neg(); } constexpr Mint operator~() const noexcept { return inv(); } constexpr Mint operator+(const Mint& rhs) const noexcept { return Mint(*this) += rhs; } constexpr Mint& operator+=(const Mint& rhs) noexcept { if ((v += rhs.v) >= MOD) v -= MOD; return *this; } constexpr Mint operator-(const Mint& rhs) const noexcept { return Mint(*this) -= rhs; } constexpr Mint& operator-=(const Mint& rhs) noexcept { if (v < rhs.v) v += MOD; v -= rhs.v; return *this; } constexpr Mint operator*(const Mint& rhs) const noexcept { return Mint(*this) *= rhs; } constexpr Mint& operator*=(const Mint& rhs) noexcept { v = (u64)v * rhs.v % MOD; return *this; } constexpr Mint operator/(const Mint& rhs) const noexcept { return Mint(*this) /= rhs; } constexpr Mint& operator/=(const Mint& rhs) noexcept { return *this *= rhs.inv(); } constexpr bool operator==(const Mint& rhs) const noexcept { return v == rhs.v; } constexpr bool operator!=(const Mint& rhs) const noexcept { return v != rhs.v; } friend std::ostream& operator<<(std::ostream& stream, const Mint& rhs) { return stream << rhs.v; } }; using Modint1000000007 = StaticModint<1000000007>; using Modint998244353 = StaticModint<998244353>; constexpr u64 ceil_log2(const u64 x) { u64 e = 0; while (((u64)1 << e) < x) ++e; return e; } template class AutoReallocation { using R = typename decltype(std::declval()((usize)0))::value_type; F func; mutable std::vector data; public: explicit AutoReallocation(F&& f) : func(std::forward(f)), data() {} void reserve(const usize size) const { if (data.size() < size) data = func(((usize)1 << ceil_log2(size))); } R operator[](const usize i) const { reserve(i + 1); return data[i]; } }; template decltype(auto) auto_realloc(F&& f) { using G = std::decay_t; return AutoReallocation(std::forward(f)); } template struct ModintUtil { static inline const auto fact = auto_realloc([](const usize n) { std::vector ret(n); ret[0] = M(1); for (const usize i : rep(1, n)) { ret[i] = ret[i - 1] * M(i); } return ret; }); static inline const auto inv = auto_realloc([](const usize n) { std::vector ret(n); if (n == 1) return ret; ret[1] = M(1); for (const usize i : rep(2, n)) { ret[i] = -M(M::mod() / i) * ret[M::mod() % i]; } return ret; }); static inline const auto inv_fact = auto_realloc([](const usize n) { std::vector ret(n); ret[0] = M(1); for (const usize i : rep(1, n)) { ret[i] = ret[i - 1] * inv[i]; } return ret; }); static M binom(const usize n, const usize k) { assert(k <= n); return fact[n] * inv_fact[n - k] * inv_fact[k]; } static M factpow(const usize n, const usize k) { assert(k <= n); return fact[n] * inv_fact[n - k]; } static M homo(const usize n, const usize k) { if (n == 0 and k == 0) return M(1); return binom(n + k - 1, k); } }; template using Vec = std::vector; using Fp = Modint998244353; using Util = ModintUtil; void main_() { usize N; std::cin >> N; Vec A(N); for (auto& x : A) { u32 y; std::cin >> y; x = y; } Vec more(N + 1); for (const auto i : rep(0, N)) { more[i] = Util::factpow(N - 1, (N - 1) - i); } Vec pow2(2 * N); pow2[0] = 1; for (const auto i : rep(1, 2 * N)) { pow2[i] = pow2[i - 1] * 2; } Vec coeff(N); { Fp sum; for (const auto i : rep(0, N - 1)) { sum += (more[i] - more[i + 1] * Util::inv[2]) * pow2[2 * ((N - 1) - i) + i]; coeff[i] = sum; } } for (const auto i : rep(0, N)) { coeff[N - 1] += more[i] * pow2[2 * ((N - 1) - i) + i]; } for (const auto k : rep(0, N + 1)) { Fp ans; for (const auto i : rep(0, N)) { ans += coeff[i] * A[i]; } std::cout << ans << '\n'; Vec next(N); for (const auto i : rep(0, N)) { next[i] += A[i] * (N - 1); if (i > 0) { next[i] += A[i - 1]; next[i] -= A[i]; } if (i < N - 1) { next[i] += A[i + 1]; next[i] -= A[i]; } } A = std::move(next); } } int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); main_(); return 0; }