Given positive integers N, K and M, solve the following problem for every integer x between 1 and N (inclusive):
 - Find the number, modulo M, of non-empty multisets containing between 0 and K (inclusive) instances of each of the integers 1, 2, 3 \cdots, N such that the average of the elements is x.

-----Constraints-----
 - 1 \leq N, K \leq 100
 - 10^8 \leq M \leq 10^9 + 9
 - M is prime.
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
N K M

-----Output-----
Use the following format:
c_1
c_2
:
c_N

Here, c_x should be the number, modulo M, of multisets such that the average of the elements is x.

-----Sample Input-----
3 1 998244353

-----Sample Output-----
1
3
1

Consider non-empty multisets containing between 0 and 1 instance(s) of each of the integers between 1 and 3. Among them, there are:
 - one multiset such that the average of the elements is k = 1: \{1\};
 - three multisets such that the average of the elements is k = 2: \{2\}, \{1, 3\}, \{1, 2, 3\};
 - one multiset such that the average of the elements is k = 3: \{3\}.

Source: atcoder | Difficulty: VERY_HARD


Solutions:
(N, K, M) = map(int, input().split())
R = range
T = [[1]]
for i in R(1, N):
	q = K * i
	if i > ~i + N:
		T += [(y := T[-1][:len(T[~i + N])])]
	else:
		T += [(y := (T[-1][:] + [0] * q))]
	p = len(y) - i
	for j in R(p):
		y[j + i] += y[j] % M
	for j in R(p - q):
		y[~j] -= y[~j - i - q] % M
for i in R(N):
	print(sum((T[i][j] * T[~i + N][j] for j in R(len(T[i])))) * -~K % M - 1)


import numpy as np
from numba import njit

@njit
def main(n, k, mod):
	l = k * (n * (n + 1)) // 2
	dp = np.zeros((n + 1, l + 1), dtype=np.int32)
	dp[0, 0] = 1
	ary = np.ones((1, l + 2), dtype=np.int32)
	ary[0, 0] = 0
	for i in range(1, n + 1):
		nary = np.zeros((i + 1, 2 + l // i), dtype=np.int32)
		for j in range(l + 1):
			a = j // i
			b = max(0, j // i - k)
			dp[i, j] = ary[j % i, a + 1] - ary[j % i, b]
			dp[i, j] %= mod
			nary[j % (i + 1), j // (i + 1) + 1] = dp[i, j]
			nary[j % (i + 1), j // (i + 1) + 1] += nary[j % (i + 1), j // (i + 1)]
			nary[j % (i + 1), j // (i + 1) + 1] %= mod
		ary = nary
	ret = []
	for i in range(1, n + 1):
		ans = 0
		num = dp[i - 1, 0]
		num *= dp[n - i, 0]
		ans += num * k
		ans %= mod
		for j in range(1, l + 1):
			num = dp[i - 1, j]
			num *= dp[n - i, j]
			num %= mod
			ans += num * (k + 1) % mod
			ans %= mod
		ret.append(ans)
	return ret
(n, k, mod) = map(int, input().split())
print(*main(n, k, mod), sep='\n')


import sys
readline = sys.stdin.readline
(N, K, MOD) = list(map(int, readline().split()))
MAX = K * (N // 2) * (N // 2 + 1) // 2 + 1
table = [[1]]
for idx in range(1, N + 1):
	dp = table[-1]
	dp2 = dp + [0] * (idx * (K + 1))
	s = idx * (K + 1)
	for i in range(min(len(dp), len(dp2) - s)):
		dp2[i + s] = (dp2[i + s] + -dp[i]) % MOD
	for i in range(len(dp2) - idx):
		dp2[i + idx] = (dp2[i + idx] + dp2[i]) % MOD
	if len(dp2) > MAX:
		dp2 = dp2[:MAX]
	table.append(dp2)
Ans = [None] * (N + 1)
for x in range(1, N + 1):
	if N - x < x:
		Ans[x] = Ans[N + 1 - x]
	ans = 0
	for i in range(min(len(table[x - 1]), len(table[N - x]))):
		ans = (ans + table[x - 1][i] * table[N - x][i]) % MOD
	ans = (ans * (K + 1) - 1) % MOD
	Ans[x] = ans
print('\n'.join(map(str, Ans[1:])))