#include <iostream>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <numeric>
#include <fstream>
#include <iomanip>

using ll = long long;
const ll MOD = 1000000007;

// ------------------------------------------------------
// Output
// ------------------------------------------------------
template<class T, class S> std::ostream& operator << (std::ostream& os, std::pair<T, S> p)
{
  return os << "(" << p.first << " " << p.second << ")";
}

template<class T> std::ostream& operator << (std::ostream& os, std::vector< T > v)
{
  for (ll i = 0; i < (ll)v.size(); i++){ os << " [" << i << "]" << v[i]; if (i % 10 == 9) os << std::endl; }
  //os << v[0]; for (ll i = 1; i < (ll)v.size(); i++){ os << " " << v[i]; }
  return os;
}

template<class T, class S> std::ostream& operator << (std::ostream& os, std::map< T, S > m)
{
  ll i = 0; for (auto p : m){ os << " [" << i << "]" << p.first << "->" << p.second; i++;}
  return os;
}

void print(){ std::cout << std::endl; }
template<typename H> void print(H head) { std::cout << head << std::endl; }
template<typename H, typename... T> void print(H head, T... tail){ std::cout << head << " ", print(tail...); }

// ------------------------------------------------------
// ModInt, Combination
// ------------------------------------------------------
template <ll MOD>
class ModInt {

public:
  ll val;

  // Constructor
  ModInt(ll v = 0) : val(v % MOD) {
    if (val < 0) val += MOD;
  };

  // Unary
  ModInt operator +() const {return ModInt(val); }
  ModInt operator -() const {return ModInt(MOD - val); }

  ModInt pow(ll n) const {
    ll result = 1LL;
    ll a = val;
    while (n > 0) {
      if (n & 1) result = result * a % MOD;
      a = a * a % MOD;
      n >>= 1;
    }
    return result;
  }

  ModInt inv() const {
    return pow(MOD-2);
  }

  // Assignment, Compound
  ModInt& operator = (const ModInt& x) { if (this != &x) {val = x.val;}          return *this; }
  ModInt& operator +=(const ModInt& x) { if ((val += x.val) >= MOD){val -= MOD;} return *this; }
  ModInt& operator -=(const ModInt& x) { if ((val -= x.val) <  0LL){val += MOD;} return *this; }
  ModInt& operator *=(const ModInt& x) { val = val * x.val % MOD;                return *this; }
  ModInt& operator %=(const ModInt& x) { val %= x.val;                           return *this; }
  ModInt& operator /=(const ModInt& x) { *this *= x.inv();                       return *this; }

  // Arithmetic
  ModInt operator +(const ModInt& x) const { return ModInt(*this) += x; }
  ModInt operator -(const ModInt& x) const { return ModInt(*this) -= x; }
  ModInt operator *(const ModInt& x) const { return ModInt(*this) *= x; }
  ModInt operator %(const ModInt& x) const { return ModInt(*this) %= x; }
  ModInt operator /(const ModInt& x) const { return ModInt(*this) /= x; }

  // Increment, Decrement
  ModInt& operator ++()    { val += 1; return *this;}
  ModInt& operator --()    { val -= 1; return *this;}
  ModInt  operator ++(int) { ModInt before = *this; ++(*this); return before;}
  ModInt  operator --(int) { ModInt before = *this; --(*this); return before;}

  // Compare
  bool operator ==(const ModInt& b) const { return val == b.val; }
  bool operator !=(const ModInt& b) const { return val != b.val; }
  bool operator < (const ModInt& b) const { return val <  b.val; }
  bool operator <=(const ModInt& b) const { return val <= b.val; }
  bool operator > (const ModInt& b) const { return val >  b.val; }
  bool operator >=(const ModInt& b) const { return val >= b.val; }

  friend std::ostream& operator <<(std::ostream& os, const ModInt& x) { return os << x.val; }
};

template <int MOD>
class Combination {
  using mint = ModInt<MOD>;

public:
  explicit Combination(ll N) : MAX_V(N), fact(MAX_V + 1) {
    fact[0] = 1;
    for (ll i = 1; i <= MAX_V; i++) {
      fact[i] = fact[i-1] * i;
    }
  }

  mint comb(ll a, ll b) const {
    return a < b ? mint(0) : fact[a] / fact[a-b] / fact[b];
  }
private:
  ll MAX_V;
  std::vector< mint > fact;
};

using mint=ModInt<MOD>;

// ----------------------------------------------------------------------------------------
//  O O O O O O O O   赤玉 N-K 個
// ^ ^ ^ ^ ^ ^ ^ ^ ^  N-K+1 箇所から i 箇所を選ぶ
// -> Combination(N-K+1, i)
//
// ^ ^ ^ ^ ^ ^ ^ ^ ^  i箇所に 1 個以上の青玉を配置
//
// O O O O O O O O O  青玉 K 個のチーム分け
//  ^ ^ ^ ^ ^ ^ ^ ^   K-1 箇所から i-1 個の仕切りを立てる (端に仕切りを立てると０個でも良くなるため)
// -> Combination(K-1, i-1)
//
// 答えは Combination(N-K+1, i) * Combination(K-1, i-1)
// ----------------------------------------------------------------------------------------

int main()
{
  int N, K;
  std::cin >> N >> K;

  const Combination<MOD> C(10000);

  for (int i = 1; i <= K; i++) {
    mint ans = C.comb(N - K + 1, i) * C.comb(K - 1, i - 1);
    print(ans);
  }

  return 0;
}


Measured memory_bytes: 384