import sys

stdin = sys.stdin



sys.setrecursionlimit(10 ** 7)



def li(): return list(map(int, stdin.readline().split()))

def li_(): return [int(x) - 1 for x in stdin.readline().split()]

def lf(): return list(map(float, stdin.readline().split()))

def ls(): return stdin.readline().split()

def ns(): return stdin.readline().rstrip()

def lc(): return list(ns())

def ni(): return int(stdin.readline())

def nf(): return float(stdin.readline())





class CombTools(object):

    def __init__(self, cap: int, mod: int):

        self.cap = cap

        self.mod = mod

        self.inv = self._calc_inv()

        self.fac = self._calc_fac()

        self.fac_inv = self._calc_fac_inv()



    def _calc_inv(self):

        inv = [0, 1]

        for i in range(2, self.cap+1):

            inv.append((self.mod - (self.mod // i) * inv[self.mod % i]) % self.mod)



        return inv



    def _calc_fac(self):

        fac = [1]

        for i in range(1, self.cap+1):

            fac.append((i * fac[-1]) % self.mod)



        return fac



    def _calc_fac_inv(self):

        fac_inv = [1]

        for i in range(1, self.cap+1):

            fac_inv.append((self.inv[i] * fac_inv[-1]) % self.mod)



        return fac_inv



    def nCr(self, n: int, r: int):

        # validation

        if r > n:

            raise ValueError("n must be larger than r (n={}, r={})".format(n, r))



        # calculation

        return self.fac[n] * self.fac_inv[n-r] * self.fac_inv[r] % self.mod



    def nPr(self, n: int, r: int):

        # validation

        if r > n:

            raise ValueError("n must be larger than r (n={}, r={})".format(n, r))



        # calculation

        return self.fac[n] * self.fac_inv[n-r] % self.mod



    def nHr(self, n: int, r: int):

        return self.nCr(n+r-1, n)





n, k = li()



CAP = 10**5

MOD = 10**9 + 7

ct = CombTools(CAP, MOD)



for i in range(1, k+1):

    if n-k-i+1 < 0:

        print((0))

    else:

        ans = ct.nHr(n-k-i+1, i+1) * ct.nHr(k-i, i)

        print((ans % MOD))
import sys

stdin = sys.stdin



sys.setrecursionlimit(10 ** 7)



def li(): return list(map(int, stdin.readline().split()))

def li_(): return [int(x) - 1 for x in stdin.readline().split()]

def lf(): return list(map(float, stdin.readline().split()))

def ls(): return stdin.readline().split()

def ns(): return stdin.readline().rstrip()

def lc(): return list(ns())

def ni(): return int(stdin.readline())

def nf(): return float(stdin.readline())





class CombTools(object):

    def __init__(self, cap: int, mod: int):

        self.cap = cap

        self.mod = mod

        self.inv = self._calc_inv()

        self.fac = self._calc_fac()

        self.fac_inv = self._calc_fac_inv()



    def _calc_inv(self):

        inv = [0, 1]

        for i in range(2, self.cap+1):

            inv.append((self.mod - (self.mod // i) * inv[self.mod % i]) % self.mod)



        return inv



    def _calc_fac(self):

        fac = [1]

        for i in range(1, self.cap+1):

            fac.append((i * fac[-1]) % self.mod)



        return fac



    def _calc_fac_inv(self):

        fac_inv = [1]

        for i in range(1, self.cap+1):

            fac_inv.append((self.inv[i] * fac_inv[-1]) % self.mod)



        return fac_inv



    def nCr(self, n: int, r: int):

        # validation

        # if r > n:

        #     raise ValueError("n must be larger than r (n={}, r={})".format(n, r))

        # calculation

        return self.fac[n] * self.fac_inv[n-r] * self.fac_inv[r] % self.mod



    def nPr(self, n: int, r: int):

        # validation

        if r > n:

            raise ValueError("n must be larger than r (n={}, r={})".format(n, r))



        # calculation

        return self.fac[n] * self.fac_inv[n-r] % self.mod



    def nHr(self, n: int, r: int):

        return self.nCr(n+r-1, n)





n, k = li()

mod = 10 ** 9 + 7



ct = CombTools(2*n+1, mod)



for i in range(1, k+1):

    if n-k-i+1 < 0:

        print((0))

    else:

        print((ct.nHr(k-i, i) * ct.nHr(n-k-i+1, i+1) % mod))
import sys

stdin = sys.stdin
sys.setrecursionlimit(10**7)


def li():
    return list(map(int, stdin.readline().split()))


def li_():
    return [int(x) - 1 for x in stdin.readline().split()]


def lf():
    return list(map(float, stdin.readline().split()))


def ls():
    return stdin.readline().split()


def ns():
    return stdin.readline().rstrip()


def lc():
    return list(ns())


def ni():
    return int(stdin.readline())


def nf():
    return float(stdin.readline())


class CombTools(object):
    def __init__(self, cap: int, mod: int):
        self.cap = cap
        self.mod = mod
        self.inv = self._calc_inv()
        self.fac = self._calc_fac()
        self.fac_inv = self._calc_fac_inv()

    def _calc_inv(self):
        inv = [0, 1]
        for i in range(2, self.cap + 1):
            inv.append((self.mod - (self.mod // i) * inv[self.mod % i]) % self.mod)
        return inv

    def _calc_fac(self):
        fac = [1]
        for i in range(1, self.cap + 1):
            fac.append((i * fac[-1]) % self.mod)
        return fac

    def _calc_fac_inv(self):
        fac_inv = [1]
        for i in range(1, self.cap + 1):
            fac_inv.append((self.inv[i] * fac_inv[-1]) % self.mod)
        return fac_inv

    def nCr(self, n: int, r: int):
        # validation
        if r > n:
            raise ValueError("n must be larger than r (n={}, r={})".format(n, r))
        # calculation
        return self.fac[n] * self.fac_inv[n - r] * self.fac_inv[r] % self.mod

    def nPr(self, n: int, r: int):
        # validation
        if r > n:
            raise ValueError("n must be larger than r (n={}, r={})".format(n, r))
        # calculation
        return self.fac[n] * self.fac_inv[n - r] % self.mod

    def nHr(self, n: int, r: int):
        return self.nCr(n + r - 1, n)


n, k = li()
CAP = 10**5
MOD = 10**9 + 7
ct = CombTools(CAP, MOD)
for i in range(1, k + 1):
    if n - k - i + 1 < 0:
        print((0))
    else:
        ans = ct.nHr(n - k - i + 1, i + 1) * ct.nHr(k - i, i)
        print((ans % MOD))

import sys

stdin = sys.stdin
sys.setrecursionlimit(10**7)


def li():
    return list(map(int, stdin.readline().split()))


def li_():
    return [int(x) - 1 for x in stdin.readline().split()]


def lf():
    return list(map(float, stdin.readline().split()))


def ls():
    return stdin.readline().split()


def ns():
    return stdin.readline().rstrip()


def lc():
    return list(ns())


def ni():
    return int(stdin.readline())


def nf():
    return float(stdin.readline())


class CombTools(object):
    def __init__(self, cap: int, mod: int):
        self.cap = cap
        self.mod = mod
        self.inv = self._calc_inv()
        self.fac = self._calc_fac()
        self.fac_inv = self._calc_fac_inv()

    def _calc_inv(self):
        inv = [0, 1]
        for i in range(2, self.cap + 1):
            inv.append((self.mod - (self.mod // i) * inv[self.mod % i]) % self.mod)
        return inv

    def _calc_fac(self):
        fac = [1]
        for i in range(1, self.cap + 1):
            fac.append((i * fac[-1]) % self.mod)
        return fac

    def _calc_fac_inv(self):
        fac_inv = [1]
        for i in range(1, self.cap + 1):
            fac_inv.append((self.inv[i] * fac_inv[-1]) % self.mod)
        return fac_inv

    def nCr(self, n: int, r: int):
        # validation
        # if r > n:
        #     raise ValueError("n must be larger than r (n={}, r={})".format(n, r))
        # calculation
        return self.fac[n] * self.fac_inv[n - r] * self.fac_inv[r] % self.mod

    def nPr(self, n: int, r: int):
        # validation
        if r > n:
            raise ValueError("n must be larger than r (n={}, r={})".format(n, r))
        # calculation
        return self.fac[n] * self.fac_inv[n - r] % self.mod

    def nHr(self, n: int, r: int):
        return self.nCr(n + r - 1, n)


n, k = li()
mod = 10**9 + 7
ct = CombTools(2 * n + 1, mod)
for i in range(1, k + 1):
    if n - k - i + 1 < 0:
        print((0))
    else:
        print((ct.nHr(k - i, i) * ct.nHr(n - k - i + 1, i + 1) % mod))

-        if r > n: -            raise ValueError("n must be larger than r (n={}, r={})".format(n, r)) +        # if r > n: +        #     raise ValueError("n must be larger than r (n={}, r={})".format(n, r)) -CAP = 10**5 -MOD = 10**9 + 7 -ct = CombTools(CAP, MOD) +mod = 10**9 + 7 +ct = CombTools(2 * n + 1, mod) -        ans = ct.nHr(n - k - i + 1, i + 1) * ct.nHr(k - i, i) -        print((ans % MOD)) +        print((ct.nHr(k - i, i) * ct.nHr(n - k - i + 1, i + 1) % mod))