package main

import (
	"fmt"
)

func power(base, exp int64) int64 {
	res := int64(1)
	base %= 1000000007
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % 1000000007
		}
		base = (base * base) % 1000000007
		exp /= 2
	}
	return res
}

func modInverse(n int64) int64 {
	return power(n, 1000000007-2)
}

func main() {
	var n, k int
	if _, err := fmt.Scan(&n, &k); err != nil {
		return
	}

	MOD := int64(1000000007)

	C := make([][]int64, k+5)
	for i := range C {
		C[i] = make([]int64, k+5)
		C[i][0] = 1
		for j := 1; j <= i; j++ {
			C[i][j] = (C[i-1][j-1] + C[i-1][j]) % MOD
		}
	}

	B := make([]int64, k+5)
	B[0] = 1
	for m := 1; m <= k+1; m++ {
		sum := int64(0)
		for j := 0; j < m; j++ {
			sum = (sum + C[m+1][j]*B[j]) % MOD
		}
		sum = (sum * modInverse(int64(m+1))) % MOD
		B[m] = (MOD - sum) % MOD
	}

	N := int64(n) % MOD
	N_pow := make([]int64, k+5)
	N_pow[0] = 1
	for i := 1; i <= k+2; i++ {
		N_pow[i] = (N_pow[i-1] * N) % MOD
	}

	P := make([]int64, k+5)
	for p := 1; p <= k; p++ {
		sum := int64(0)
		for j := 0; j <= p; j++ {
			term := (C[p+1][j] * B[j]) % MOD
			term = (term * N_pow[p+1-j]) % MOD
			sum = (sum + term) % MOD
		}
		P[p] = (sum * modInverse(int64(p+1))) % MOD
	}

	e := make([]int64, k+5)
	e[0] = 1
	for m := 1; m <= k; m++ {
		sum := int64(0)
		for i := 1; i <= m; i++ {
			term := (e[m-i] * P[i]) % MOD
			if i%2 == 1 {
				sum = (sum + term) % MOD
			} else {
				sum = (sum - term + MOD) % MOD
			}
		}
		e[m] = (sum * modInverse(int64(m))) % MOD
	}

	for j := 1; j <= k; j++ {
		ans := int64(0)
		for m := j % 2; m <= j; m += 2 {
			ans = (ans + e[m]) % MOD
		}
		if j > 1 {
			fmt.Print(" ")
		}
		fmt.Print(ans)
	}
	fmt.Println()
}