// Original C++ solution (slower):
#include <iostream>

#include <vector>



#define rep(i, n) for(int i = 0; i < (int)(n); i++)

typedef long long ll;

using namespace std;



#ifdef DEBUG

    #define IFD if(true)

#else

    #define IFD if(false)

#endif



#include <vector>

template<typename T_mc_data>



class ModComb

{

private:

    int max_n;

    T_mc_data mod; // M

    vector<vector<T_mc_data>> table;



public:



    // 引数: n の最大値、M は mod の値

    ModComb(int n, T_mc_data M) : table(n + 1, vector<T_mc_data>(n + 1))

    {

        max_n = n;

        mod = M;

        for(int i = 0; i <= n; i++) {

            table[i][0] = 1;

            table[i][i] = 1;

            for(int j = 1; j < i; j++) {

                table[i][j] = (table[i - 1][j - 1] + table[i - 1][j]) % mod;

            }

            /* // デバッグ出力

            for(int j = 0; j <= i; j++) {

                cout << table[i][j] << " ";

            }

            cout << endl;

            */

        }

    }



    // aCb を求める

    T_mc_data calc(T_mc_data a, T_mc_data b)

    {

        if(a > max_n || a < b || a < 0) return 0; // error

        if(a == 0 && b == 0) return 1;

        return table[a][b];

    }

};



/////





int main()

{

    int N, K;

    cin >> N >> K;

    ll mod = 1000000007;

    ModComb<ll> mc(N, mod);



    rep(i, K) {

        ll ans = 0;

        // (N-K+1)C(i+1) 赤い石の間に青い石を入れる総数

        IFD cout << "i: " << i << endl << N - K + 1 << " " << i + 1 << " " << K - 1 << endl;

        ans = mc.calc(N - K + 1, i + 1);

        if(i != 0) {

            // (K-1)C(i) 青い石の塊ごとに何個ずつにするかの総数

            ans = ans * mc.calc(K - 1, i) % mod;

        }

        cout << ans << endl;

    }



    return 0;

}


// Optimized solution to the same problem (faster):
#include <iostream>

#include <vector>



#define rep(i, n) for(int i = 0; i < (int)(n); i++)

typedef long long ll;

using namespace std;



#ifdef DEBUG

    #define IFD if(true)

#else

    #define IFD if(false)

#endif



//////////////////////////////////////////////////

//

// フェルマーの小定理による実装

// （mod の値は素数である必要があるが、大きい n に対応可能）

//



// 参考 : https://qiita.com/ofutonfuton/items/92b1a6f4a7775f00b6ae



#include <vector>

template<typename T_mcf_data>



class ModCombF

{

private:

    int max_n;

    T_mcf_data mod; // M

    std::vector<T_mcf_data> fac; // n! (mod M)

    std::vector<T_mcf_data> ifac; // k!^{M - 2} (mod M)



    T_mcf_data mpow(T_mcf_data x, T_mcf_data n)

    {

        T_mcf_data ans = 1;

        while(n != 0) {

            if(n & 1) {

                ans = ans * x % mod;

            }

            x = x * x % mod;

            n = n >> 1;

        }

        return ans;

    }



public:



    // 引数: n の最大値、M は mod の値

    ModCombF(int n, T_mcf_data M) : fac(n + 1), ifac(n + 1)

    {

        max_n = n;

        mod = M;

        fac[0] = 1;

        ifac[0] = 1;

        for(int i = 0; i < n; i++) {

            fac[i + 1] = fac[i] * (i + 1) % mod;

            ifac[i + 1] = ifac[i] * mpow(i + 1, mod - 2) % mod;

        }

    }



    // aCb を求める

    T_mcf_data calc(T_mcf_data a, T_mcf_data b)

    {

        if(a > max_n || a < b || a < 0) return 0; // error

        if(a == 0 && b == 0) return 1;

        T_mcf_data tmp = ifac[a - b] * ifac[b] % mod;

        return tmp * fac[a] % mod;

    }

};

//////////////////////////////////////////////////







int main()

{

    int N, K;

    cin >> N >> K;

    ll mod = 1000000007;

    ModCombF<ll> mc(N, mod);



    rep(i, K) {

        ll ans = 0;

        // (N-K+1)C(i+1) 赤い石の間に青い石を入れる総数

        IFD cout << "i: " << i << endl << N - K + 1 << " " << i + 1 << " " << K - 1 << endl;

        ans = mc.calc(N - K + 1, i + 1);

        if(i != 0) {

            // (K-1)C(i) 青い石の塊ごとに何個ずつにするかの総数

            ans = ans * mc.calc(K - 1, i) % mod;

        }

        cout << ans << endl;

    }



    return 0;

}


// Fastest known solution for this problem: