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 1.  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.
The first line contains two integers, *N* (1 ≤ *N* ≤ 10<sup class="upper-index">5</sup>) — the maximum number written on the blackboard — and *M* (0 ≤ *M* ≤ 10<sup class="upper-index">18</sup>) — the number of steps to perform.

The second line contains *N* + 1 integers *P*<sub class="lower-index">0</sub>, *P*<sub class="lower-index">1</sub>, ..., *P*<sub class="lower-index">*N*</sub> (0 ≤ *P*<sub class="lower-index">*i*</sub> &lt; 998244353), where *P*<sub class="lower-index">*i*</sub> describes the probability that the starting number is *i*. We can express this probability as irreducible fraction *P* / *Q*, then <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a86b64174e5f1a74431a9b4b5e2e810fecd7ce1e.png" style="max-width: 100.0%;max-height: 100.0%;"/>. It is guaranteed that the sum of all *P*<sub class="lower-index">*i*</sub>s equals 1 (modulo 998244353).
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.
import operator
import sys

modulus = 998244353


class Integer:
    def __init__(self, value):
        if not isinstance(value, (int, str)):
            raise ValueError('Value must be integer or string')
        self.value = int(value) % modulus

    def __repr__(self):
        return f'{self.value}'

    def __int__(self):
        return self.value

    def inverse(self):
        return Integer(pow(self.value, modulus - 2, modulus))

    def _check_operand(self, other):
        if not isinstance(other, (int, Integer)):
            raise TypeError('Only integer and Integer operands are supported')

    def __pow__(self, exponent):
        self._check_operand(exponent)
        if exponent < 0:
            base = self.inverse().value
        else:
            base = self.value

        return Integer(pow(base, abs(exponent), modulus))


def _make_operator_by_modulo(operator_name):
    operator_function = getattr(operator, operator_name)

    def operator_by_modulo(self, operand):
        self._check_operand(operand)
        return Integer(operator_function(self.value, int(operand)) % modulus)

    return operator_by_modulo


def _make_reflected_operator_by_modulo(operator_name):
    operator_function = getattr(operator, operator_name)

    def operator_by_modulo(self, operand):
        self._check_operand(operand)
        return Integer(operator_function(int(operand), self.value) % modulus)

    return operator_by_modulo


for operator_name, reflected_operator_name in [('__add__', '__radd__'), ('__sub__', '__rsub__'),
                                               ('__mul__', '__rmul__')]:
    setattr(Integer, operator_name, _make_operator_by_modulo(operator_name))
    setattr(Integer, reflected_operator_name, _make_reflected_operator_by_modulo(operator_name))


N, M, *P = map(int, sys.stdin.read().split())
P = [*map(Integer, P)]

binomials = [Integer(1)]
R = [Integer(0)] * (N + 1)
powers = [Integer(k) ** -M for k in range(1, N + 2)]
Q = powers[:]
for n in range(N + 1):
    for i in range(n, 0, -1):
        Q[i - 1] -= Q[i]
    for i in range(n + 1):
        R[i] += P[n] * binomials[i] * Q[i]
    binomials = [Integer(1)] + [b1 + b2 for b1, b2 in zip(binomials, binomials[1:])] + [Integer(1)]
print(*R)