// Original C++ solution (slower):
#include<bits/stdc++.h>

#include<iostream>

#include<math.h>

#include<vector>

#include<set>

#include<queue>

#include<algorithm>

#include<cstring>    //for memset

using namespace std;



//#include <ext/pb_ds/assoc_container.hpp>

//#include <ext/pb_ds/tree_policy.hpp>

//using namespace __gnu_pbds;



#define lli                      long long int

#define ull                      unsigned long long

#define ld                       long double

#define pi                       acos(-1)

#define pb                       push_back

#define pbk                      pop_back

#define ff                       first

#define ss                       second

#define pii                      pair<int,int>

#define pdd                      pair<double,double>

#define gcd(a,b)                 __gcd(a,b)

#define lcm(a,b)                (a/gcd(a,b))*b

#define all(v)                   v.begin(),v.end()

#define READ                     freopen("in.txt","r",stdin);

#define WRITE                    freopen("outer.txt","w",stdout);

#define mem(array,value)         memset(array,value,sizeof array)

#define TEST_CASE                int t;scanf("%d",&t);for(int z=1;z<=t;z++)

#define PRINT_CASE               printf("Case %d: ",z)

#define LINE_PRINT_CASE          printf("Case %d:\n",z)

#define ordered_set              tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>

#define sf                       scanf

#define pf                       printf

#define inf                      99999999999

#define mod                      1000000007

#define dist(ax,ay,bx,by)        sqrt((ax-bx)*(ax-bx)+(ay-by)*(ay-by))

#define fastIO                   ios_base::sync_with_stdio(false); cin.tie(0);cout.tie(0);

#define watch(x)   	            cerr << __LINE__ << ": " << #x << " = " << (x) << '\n'

#define mx 1000005



lli fact[2222];

lli invFact[2222];



lli bigmod ( lli b, lli p, lli m ) {

    lli res=1%m, x=b%m;

    while(p){

        if(p&1) //check if 0th bit is 1

           res=(res*x)%m;

        x=(x*x)%m;

        p>>=1;

        //cout<<"p "<<p<<endl; //right shift so that we can work only with 0th bit

    }

    return res;

}



pii extended_euclid(lli a,lli b){

        if(b==0){

                return pii(1,0);

        }else{

                pii d = extended_euclid(b,a%b);

                return pii(d.ss,d.ff-d.ss*(a/b));

        }

}



lli modular_inverse(lli a){

    pii ret = extended_euclid(a,mod);

    return ((ret.ff%mod)+mod)%mod;



}



void factorial(){

    fact[0]=fact[1]=invFact[0]=invFact[1]=1;



	for(lli x=2;x<2222;x++){

	    fact[x]=(fact[x-1]*x)%mod;

	    invFact[x]=modular_inverse(fact[x]);

	}

}





int main()

{



    factorial();

    //cout<<fact[1]<<" "<<invFact[-1]<<endl;

     int n,k;

    cin>>n>>k;

    for(int i=1; i<=k; i++)

    {

          int p=n-k+1;

          if(p>=i){

          lli ans1=((((fact[p]*invFact[i])%mod)*invFact[p-i])%mod)%mod;//pCi

          //cout<<"pppp "<<ans1<<endl;

          lli ans2=((((fact[k-1]*invFact[k-i])%mod)*invFact[i-1])%mod)%mod;//(k-1)C(i-1)

          //cout<<"qqqq"<<ans2<<endl;

          cout<<(ans1*ans2)%mod<<endl;}

          else

          {

                  cout<<"0"<<endl;

          }





    }

    return 0;

}
















// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



const int mxn = 2003;

const long long mod = 1e9 + 7;



long long c[mxn][mxn];



int main() {



    int n, k;



    cin >> n >> k;



    c[0][0] = c[1][1] = c[1][0] = 1;

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

        c[i][0] = c[i][i] = 1;

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

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

        }

    }

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

        cout << (c[k - 1][i - 1] * c[n - k + 1][i]) % mod << endl;

    }



    return 0;

}


// Fastest known solution for this problem: