#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<string>
#include<cstring>
#include<algorithm>
#include<sstream>
#include<complex>
#include<functional>
#include<vector>
#include<map>
#include<queue>
#include<deque>
#include<stack>
#include<set>

using namespace std;
#define endl '\n'
#define eb emplace_back
#define fst first
#define scd second

constexpr int mod = 1000000007;

using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;

ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }

// value
template<typename T, T MOD = 1000000007>
struct Mint {

    static constexpr T mod = MOD;

    T v;
    
    /* コンストラクタ群 */
    Mint():v(0){}

    Mint(signed _v):v(_v){}

    Mint(long long t){
        v = t % mod;
        if (v < 0) v += mod;
    }

    Mint pow(long long k){
        Mint res(1), tmp(v);
        while(k) {
            if(k & 1) res *= tmp;
            tmp *= tmp;
            k >>= 1;
        }
        return res;
    }

    static Mint add_identity(){return Mint(0);}
    static Mint mul_identyty(){return Mint(1);}
    
    /* 逆元を求める */
    // オイラーの定理
    Mint inv(){return pow(mod - 2);}

    // 拡張ユークリッド互除法
    Mint inv_euclid(){
        Mint u(1), v(0), tmp(v), b(mod);
        while(b.v){
            Mint t = tmp / b;
            tmp -= t * b;
            u -= t * v;
            swap(u, v);
        }
        return u;
    }

    /* 演算子群 */
    Mint& operator+=(Mint a){
        v += a.v;
        if (v >= mod) v -= mod;
        return *this;
    }

    Mint& operator-=(Mint a){
        v += mod - a.v;
        if (v >= mod) v -= mod;
        return *this;
    }

    Mint& operator*=(Mint a){
        v = 1LL * v * a.v % mod;
        return *this;
    }

    Mint& operator/=(Mint a){
        return (*this) *= a.inv();
    }

    Mint operator+(Mint a) const {return Mint(v) += a;}

    Mint operator-(Mint a) const {return Mint(v) -= a;}

    Mint operator*(Mint a) const {return Mint(v) *= a;}

    Mint operator/(Mint a) const {return Mint(v) /= a;}

    Mint operator-() const {return v ? Mint(mod - v) : Mint(v);}

    bool operator==(const Mint a) const {return v == a.v;}

    bool operator!=(const Mint a) const {return v != a.v;}

    bool operator<(const Mint a) const {return v < a.v;}

    bool operator>(const Mint a) const {return v > a.v;}

    /* 組み合わせ */
    static Mint comb(long long n, int k) {
        Mint num(1), dom(1);
        for(int i=0;i < k; i++){
            num *= Mint(n - i);
            dom *= Mint(i + 1);
        }
        return num / dom;
    }

};

template<typename T, T MOD> constexpr T Mint<T, MOD>::mod;
template<typename T, T MOD>
ostream& operator<<(ostream &os, Mint<T, MOD> m){ os << m.v; return os;}

using M = Mint<ll>;

M fact[2010];

void calc_fact(){
    fact[0] = M(1);
    for(int i = 1;i < 2010; i++){
        fact[i] = M(i) * fact[i - 1];
    }
}

M comb(ll n, ll r){
    if (r == 0) return 1;
    return fact[n] / fact[r] / fact[n - r];
}

void solve() {

    int N, K;
    cin >> N >> K;

    calc_fact();

    for (int i = 1; i <= K; i++){
        if (N - K + 1 < i){
            cout << 0 << endl;
            continue;
        }
        M ans(comb(K - 1, i - 1) * comb(N - K + 1, i));
        cout << ans << endl;
    }

	return;

}

int main() {

	cin.tie(0);
	ios::sync_with_stdio(false);

	solve();

	return 0;

}

Measured memory_bytes: 256