import sys
input = lambda :sys.stdin.readline()[:-1]
ni = lambda :int(input())
na = lambda :list(map(int,input().split()))
yes = lambda :print("yes");Yes = lambda :print("Yes")
no = lambda :print("no");No = lambda :print("No")
inf = 10**16
#######################################################################

mod = 998244353
nn = 10 ** 6
fact = [1] * nn
for i in range(nn - 1):
    fact[i + 1] = fact[i] * (i + 1) % mod
invfact = [1] * nn
invfact[nn - 1] = pow(fact[nn - 1], mod - 2, mod)
for i in range(nn - 1)[::-1]:
    invfact[i] = invfact[i + 1] * (i + 1) % mod
 
def binom(x, y):
    if x < 0 or y < 0 or x - y < 0:
        return 0
    return fact[x] * invfact[y] % mod * invfact[x - y] % mod

def path(x):
    if x == 1:
        return 1
    else:
        return fact[x] * pow(2, mod-2, mod) % mod

"""
[1, 1, 3]

a を固定する

sum_{T 木} sum_{p in T} (p が 全て a以下なら ) ^ K

p を固定する

k = |p| pを含むような木が何個あるか

k * n^{n-k-1}

全てa以下で，長さがkのパスの個数
c(a, k) * k!/2

a!/(a-k)! * k * n ^ {n - k - 1} * (k-1) ^ K / 2
a! * n^(n-1)/2 * (a-k)! * k * (k-1)^K  * n^{-k}
"""

def naive(n, K):
    ans = [0] * (n + 1)
    for a in range(1, n + 1):
        for k in range(2, a + 1):
            ans[a] += binom(a, k) * path(k) * k * pow(n, n - k - 1, mod) * pow(k-1, K, mod)
            ans[a] %= mod


    return ans
from atcoder.convolution import convolution

def solve(n, K):
    f = [0] * (n + 1)
    g = [0] * (n + 1)
    ninv = pow(n, mod-2, mod)
    for i in range(n + 1):
        f[i] = invfact[i]
        g[i] = i * pow(i - 1, K, mod) * pow(ninv, i, mod) % mod
    # print(f, g)
    h = convolution(mod, f, g)
    # print(h)
    Z = pow(n, n - 1, mod) * pow(2, mod-2, mod) % mod
    for i in range(1, n + 1):
        h[i] *= fact[i] * Z
        h[i] %= mod
    for i in range(1, n + 1):
        print((h[i] - h[i-1]) % mod)
    

n, k = na()
# print(naive(n, k))
solve(n, k)