#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    long long tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (long long)value;
    return output;
}

int128_t cal_mod(const int128_t n, const int128_t mod) {
    // n % modを計算する。ただしmod <= 0 ならば何もしない。nが負の場合、正にして補正する。
    if (mod <= 0) {
        return n;
    } else if (0 <= n) {
        return n % mod;
    } else {
        int128_t tmp = (-n) / mod + 1;
        return (n + tmp * mod) % mod;
    }
}

int128_t pow_mod(int128_t x, int128_t n, const int128_t mod) {
    // 累乗の計算。mod <= 0ならば余りの計算は行わない。
    int128_t ret = 1;
    while (n > 0) {
        if (n & 1) { ret = cal_mod(ret * x, mod); }
        x = cal_mod(x * x, mod);
        n = (n >> 1);
    }
    return ret;
}

class Combi_Num {
    // 「組み合わせ数 % 素数」を、前処理を行ったうえでO(1)で求める。modは32bitに収まることが前提。
    public:
    int128_t mod;
    std::vector<int128_t> factorial, factorial_inv, inv;
    Combi_Num() {}
    Combi_Num(const int n, const int128_t mod_in) {
        mod = mod_in;
        factorial.resize(n+1, 0);
        factorial_inv.resize(n+1, 0);
        inv.resize(n+1, 0);
        factorial[0] = 1;
        factorial_inv[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = (factorial[i-1] * i) % mod;
            inv[i] = pow_mod(i, mod - 2, mod);
            factorial_inv[i] = (factorial_inv[i-1] * inv[i]) % mod;
        }
    }

    int128_t combi(const int n, const int r) {
        return (factorial[n] * ((factorial_inv[r] * factorial_inv[n-r]) % mod)) % mod;
    }

    int128_t perm(const int n, const int r) {
        return (factorial[n] * factorial_inv[n-r]) % mod;
    }

    // n個の要素をr個のグループに分ける場合の数。要素数0のグループがあってもよい。
    // 0個の要素を0個のグループに分ける場合の数は1とする。
    int128_t separate(const int n, const int r) {
        if (n == 0) { return 1; }
        if (r == 0) { return 0; }
        return combi(n + r - 1, r - 1);
    }
};

const int128_t MOD = 1e9 + 7;
const int MAX_N = 3000;
int N, K;

Combi_Num combi_num = Combi_Num(MAX_N, MOD);

int128_t ret[MAX_N] = {};

// M個のものをR個に分割。ただし、R個に1つは必ず存在。
int128_t calc(int M, int R) {
    if (M < R) {
        return 0;
    } else {
        return combi_num.separate(M - R, R);
    }


    /*
    if (M < R) {
        return 0;
    } else if (M == 0 && R == 0) {
        return 1;
    } else if (R == 0) {
        return 0;
    } else {
        return combi_num.combi(M - 1, R - 1);
    }
    */
}

int main(int argc, char **argv) {
    std::cin >> N >> K;

    for (int i = 1; i <= N - K + 1; i++) {
        ret[i] = combi_num.combi(N - K + 1, i) * calc(K, i);
        ret[i] %= MOD;
    }
    
    /*
    for (int i = 1; i <= K; i++) {
        int128_t num = 0;
        for (int m = 0; m <= N - K; m++) {
            //std::cout << i << " " << m << " " << calc(m, i - 1) << std::endl;
            num += calc(m, i - 1) * combi_num.combi(K - 1, i - 1) * (N - K - m + 1);
            num %= MOD;
        }
        ret[i] = num;
    }
    */

    for (int i = 1; i <= K; i++) {
        std::cout << ret[i] << std::endl;
    }
    
    return 0;
}

Measured memory_bytes: 512