Problem: There is a number x initially written on a blackboard. You repeat the following action a fixed amount of times: 

  1. take the number x currently written on a blackboard and erase it 
  2. select an integer uniformly at random from the range [0, x] inclusive, and write it on the blackboard 



Determine the distribution of final number given the distribution of initial number and the number of steps.

Input

The first line contains two integers, N (1 ≤ N ≤ 105) — the maximum number written on the blackboard — and M (0 ≤ M ≤ 1018) — the number of steps to perform.

The second line contains N + 1 integers P0, P1, ..., PN (0 ≤ Pi < 998244353), where Pi describes the probability that the starting number is i. We can express this probability as irreducible fraction P / Q, then <image>. It is guaranteed that the sum of all Pis equals 1 (modulo 998244353).

Output

Output a single line of N + 1 integers, where Ri is the probability that the final number after M steps is i. It can be proven that the probability may always be expressed as an irreducible fraction P / Q. You are asked to output <image>.

Examples

Input

2 1
0 0 1


Output

332748118 332748118 332748118


Input

2 2
0 0 1


Output

942786334 610038216 443664157


Input

9 350
3 31 314 3141 31415 314159 3141592 31415926 314159265 649178508


Output

822986014 12998613 84959018 728107923 939229297 935516344 27254497 413831286 583600448 442738326

Note

In the first case, we start with number 2. After one step, it will be 0, 1 or 2 with probability 1/3 each.

In the second case, the number will remain 2 with probability 1/9. With probability 1/9 it stays 2 in the first round and changes to 1 in the next, and with probability 1/6 changes to 1 in the first round and stays in the second. In all other cases the final integer is 0.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
  return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
inline _Tp abs(const _Tp &a) {
  return a >= 0 ? a : -a;
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
  (a < b) && (a = b);
}
template <typename _Tp>
inline void chmin(_Tp &a, const _Tp &b) {
  (b < a) && (a = b);
}
template <typename _Tp>
inline void read(_Tp &x) {
  char ch(getchar());
  bool f(false);
  while (!isdigit(ch)) f |= ch == 45, ch = getchar();
  x = ch & 15, ch = getchar();
  while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
  f && (x = -x);
}
template <typename _Tp, typename... Args>
void read(_Tp &t, Args &...args) {
  read(t);
  read(args...);
}
inline int read_str(char *s) {
  char ch(getchar());
  while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
  char *tar = s;
  *tar++ = ch, ch = getchar();
  while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
    *tar++ = ch, ch = getchar();
  return *tar = 0, tar - s;
}
const int max_len = 1 << 18, N = max_len + 5, mod = 998244353;
int _inv_[N];
template <typename _Tp1, typename _Tp2>
inline void add(_Tp1 &a, _Tp2 b) {
  (a += b) >= mod && (a -= mod);
}
template <typename _Tp1, typename _Tp2>
inline void sub(_Tp1 &a, _Tp2 b) {
  (a -= b) < 0 && (a += mod);
}
template <typename _Tp>
inline _Tp _sub(_Tp a, const _Tp &b) {
  (a += mod - b) >= mod && (a -= mod);
  return a;
}
long long ksm(long long a, long long b = mod - 2) {
  long long res = 1;
  while (b) {
    if (b & 1) res = res * a % mod;
    a = a * a % mod, b >>= 1;
  }
  return res;
}
void print(const std::vector<int> &a) {
  for (auto it : a) printf("%d ", it);
  printf("\n");
}
std::vector<int> operator<<(const std::vector<int> &a, unsigned int b) {
  std::vector<int> o(a.size() + b);
  for (unsigned int i = 0; i < b; ++i) o[i] = 0;
  for (unsigned int i = 0; i < a.size(); ++i) o[i + b] = a[i];
  return o;
}
inline std::vector<int> operator<<=(std::vector<int> &a, unsigned int b) {
  return a = a << b;
}
inline std::vector<int> operator>>(const std::vector<int> &a, unsigned int b) {
  return b >= a.size() ? std::vector<int>()
                       : std::vector<int>{a.begin() + b, a.end()};
}
inline std::vector<int> operator>>=(std::vector<int> &a, unsigned int b) {
  return a = b >= a.size() ? std::vector<int>()
                           : std::vector<int>{a.begin() + b, a.end()};
}
std::vector<int> operator+=(std::vector<int> &a, const std::vector<int> &b) {
  if (((int)b.size()) > ((int)a.size())) a.resize(((int)b.size()));
  for (unsigned int i = 0; i < b.size(); ++i) add(a[i], b[i]);
  return a;
}
inline std::vector<int> operator+(const std::vector<int> &a,
                                  const std::vector<int> &b) {
  std::vector<int> tmp(a);
  tmp += b;
  return tmp;
}
std::vector<int> operator-=(std::vector<int> &a, const std::vector<int> &b) {
  if (((int)b.size()) > ((int)a.size())) a.resize(((int)b.size()));
  for (unsigned int i = 0; i < b.size(); ++i) sub(a[i], b[i]);
  return a;
}
inline std::vector<int> operator-(const std::vector<int> &a,
                                  const std::vector<int> &b) {
  std::vector<int> tmp(a);
  tmp -= b;
  return tmp;
}
unsigned long long Omgs[N];
int r[N];
const unsigned long long Omg = ksm(3, (mod - 1) / max_len);
int calc(int len) {
  int limit = 1;
  while (limit < len) limit <<= 1;
  for (int i = 0; i < limit; ++i)
    r[i] = (r[i >> 1] >> 1) | (i & 1 ? limit >> 1 : 0);
  return limit;
}
void setup() {
  _inv_[0] = _inv_[1] = 1;
  for (int i = 2; i < N; ++i)
    _inv_[i] = 1ULL * _inv_[mod % i] * (mod - mod / i) % mod;
  Omgs[max_len >> 1] = 1;
  for (int i = (max_len >> 1) + 1; i < max_len; ++i)
    Omgs[i] = Omgs[i - 1] * Omg % mod;
  for (int i = (max_len >> 1) - 1; i > 0; --i) Omgs[i] = Omgs[i << 1];
}
void dft(unsigned long long *A, int limit) {
  for (int i = 0; i < limit; ++i)
    if (i < r[i]) std::swap(A[i], A[r[i]]);
  for (int len = 1; len < limit; len <<= 1) {
    if (len == 262144)
      for (int i = 0; i < limit; ++i) A[i] %= mod;
    for (int i = 0; i < limit; i += len << 1) {
      unsigned long long *p = A + i, *q = A + i + len, *w = Omgs + len;
      for (int _ = 0; _ < len; ++_, ++p, ++q, ++w) {
        unsigned long long tmp = *q * *w % mod;
        *q = *p + mod - tmp, *p += tmp;
      }
    }
  }
  for (int i = 0; i < limit; ++i) A[i] %= mod;
}
void idft(unsigned long long *A, int limit) {
  std::reverse(A + 1, A + limit), dft(A, limit);
  unsigned long long inv = mod - (mod - 1) / limit;
  for (int i = 0; i < limit; ++i) A[i] = inv * A[i] % mod;
}
unsigned long long _f[N], _g[N];
std::vector<int> operator*(const std::vector<int> &a,
                           const std::vector<int> &b) {
  unsigned int len = a.size() + b.size() - 1;
  if (a.size() <= 40u || b.size() <= 40u) {
    std::vector<int> c(len);
    for (unsigned int i = 0; i < a.size(); ++i)
      for (unsigned int j = 0; j < b.size(); ++j)
        add(c[i + j], 1ull * a[i] * b[j] % mod);
    return c;
  }
  int limit = calc(len);
  memset(_f, 0, limit << 3);
  for (unsigned int i = 0; i < a.size(); ++i) _f[i] = a[i];
  memset(_g, 0, limit << 3);
  for (unsigned int i = 0; i < b.size(); ++i) _g[i] = b[i];
  dft(_f, limit), dft(_g, limit);
  for (int i = 0; i < limit; ++i) _f[i] = 1ULL * _f[i] * _g[i] % mod;
  idft(_f, limit);
  std::vector<int> ans(len);
  for (unsigned int i = 0; i < len; ++i) ans[i] = _f[i];
  return ans;
}
std::vector<int> mul(const std::vector<int> &a, const std::vector<int> &b,
                     unsigned int len, bool need = true) {
  if (a.size() <= 40u || b.size() <= 40u) {
    std::vector<int> c(((int)a.size()) + ((int)b.size()) - 1);
    for (unsigned int i = 0; i < a.size(); ++i)
      for (unsigned int j = 0; j < b.size(); ++j)
        add(c[i + j], 1ull * a[i] * b[j] % mod);
    return c.resize(len), c;
  }
  int limit = calc(len);
  memset(_f, 0, limit << 3);
  for (unsigned int i = 0; i < a.size(); ++i) _f[i] = a[i];
  dft(_f, limit);
  if (need) {
    memset(_g, 0, limit << 3);
    for (unsigned int i = 0; i < b.size(); ++i) _g[i] = b[i];
    dft(_g, limit);
  }
  for (int i = 0; i < limit; ++i) _f[i] = 1ULL * _f[i] * _g[i] % mod;
  idft(_f, limit);
  std::vector<int> ans(len);
  for (unsigned int i = 0; i < len; ++i) ans[i] = _f[i];
  return ans;
}
inline std::vector<int> operator*=(std::vector<int> &a,
                                   const std::vector<int> &b) {
  return a = a * b;
}
template <typename _Tp>
inline std::vector<int> operator*=(std::vector<int> &a, const _Tp &b) {
  for (auto &&it : a) it = 1ll * it * b % mod;
  return a;
}
template <typename _Tp>
inline std::vector<int> operator*(std::vector<int> a, const _Tp &b) {
  return a *= b;
}
template <typename _Tp>
inline std::vector<int> operator*(const _Tp &b, std::vector<int> a) {
  return a *= b;
}
template <typename _Tp>
inline std::vector<int> operator/=(std::vector<int> &a, const _Tp &b) {
  unsigned long long inv = ksm(b);
  for (auto &&it : a) it = 1ll * it * inv % mod;
  return a;
}
template <typename _Tp>
inline std::vector<int> operator/(std::vector<int> a, const _Tp &b) {
  return a /= b;
}
template <typename _Tp>
inline std::vector<int> operator/(const _Tp &b, std::vector<int> a) {
  return a /= b;
}
std::vector<int> Inv(const std::vector<int> &F) {
  if (F.size() == 1u) return {(int)ksm(F[0])};
  unsigned int len = F.size(), l = (len + 1) >> 1;
  std::vector<int> H(Inv({F.begin(), F.begin() + l})), tmp(mul(F, H, len)),
      ans(H);
  memset(tmp.data(), 0, l << 2), tmp = mul(tmp, H, len, false), ans.resize(len);
  for (unsigned int i = l; i < len; ++i) tmp[i] && (ans[i] = mod - tmp[i]);
  return ans;
}
std::pair<std::vector<int>, std::vector<int> > divide(
    const std::vector<int> &f, const std::vector<int> &g) {
  int n = ((int)f.size()), m = ((int)g.size());
  std::vector<int> F(f), G(g);
  std::reverse(F.begin(), F.end()), F.resize(n - m + 1);
  std::reverse(G.begin(), G.end()), G.resize(n - m + 1);
  std::vector<int> Q(F * Inv(G));
  Q.resize(n - m + 1), std::reverse(Q.begin(), Q.end());
  std::vector<int> R(f - Q * g);
  return R.resize(m - 1), std::make_pair(Q, R);
}
inline std::vector<int> Mod(const std::vector<int> &f,
                            const std::vector<int> &g) {
  return divide(f, g).second;
}
std::vector<int> Sqrt(const std::vector<int> &F) {
  if (F.size() == 1u) return {1};
  unsigned int len = ((int)F.size()), l = (len + 1) >> 1;
  std::vector<int> H(Sqrt({F.begin(), F.begin() + l}));
  H.resize(len);
  std::vector<int> ans(H + F * Inv(H));
  return ans.resize(len), ans / 2;
}
std::vector<int> deri(std::vector<int> a) {
  for (unsigned int i = 0; i + 1 < a.size(); ++i)
    a[i] = 1LL * (i + 1) * a[i + 1] % mod;
  return a.pop_back(), a;
}
std::vector<int> inte(std::vector<int> a) {
  a.resize(((int)a.size()) + 1);
  for (int i = ((int)a.size()) - 1; i >= 1; --i)
    a[i] = 1LL * a[i - 1] * _inv_[i] % mod;
  return a[0] = 0, a;
}
std::vector<int> Ln(std::vector<int> F) {
  std::vector<int> ans(inte(deri(F) * Inv(F)));
  return ans.resize(((int)F.size())), ans;
}
std::vector<int> Exp(const std::vector<int> &F) {
  if (F.size() == 1u) return {1};
  unsigned int len = F.size(), l = (len + 1) >> 1;
  std::vector<int> H(Exp({F.begin(), F.begin() + l}));
  H.resize(len);
  std::vector<int> tp(F - Ln(H)), ans(H);
  H.resize(l), tp = mul(tp, H, len);
  for (unsigned int i = l; i < len; ++i) ans[i] = tp[i];
  return ans;
}
std::vector<int> ksm(std::vector<int> a, int b) {
  a = Ln(a);
  for (auto &&it : a) it = 1ll * it * b % mod;
  return Exp(a);
}
long long fac[N], inv[N], ifac[N];
int main() {
  setup();
  fac[0] = fac[1] = inv[0] = inv[1] = ifac[0] = ifac[1] = 1;
  for (int i = 2; i < N; ++i)
    fac[i] = fac[i - 1] * i % mod,
    inv[i] = inv[mod % i] * (mod - mod / i) % mod,
    ifac[i] = ifac[i - 1] * inv[i] % mod;
  int n;
  long long m;
  read(n, m);
  std::vector<int> p(n + 1);
  for (int i = 0; i <= n; ++i) read(p[i]), p[i] = fac[i] * p[i] % mod;
  std::vector<int> coef(n + 1);
  for (int i = 0; i <= n; ++i) coef[i] = ifac[n - i];
  p *= coef;
  std::vector<int> a(n + 1);
  for (int i = 0; i <= n; ++i)
    a[i] = 1LL * (i & 1 ? mod - p[n + i] : p[n + i]) * ksm(inv[i + 1], m) % mod;
  a *= coef;
  for (int i = 0; i <= n; ++i)
    printf("%lld%c", (i & 1 ? mod - ifac[i] : ifac[i]) * a[i + n] % mod,
           " \n"[i == n]);
  return 0;
}