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

#include <bitset>

#include <cassert>

#include <cctype>

#include <cmath>

#include <cstdint>

#include <cstdio>

#include <cstring>

#include <deque>

#include <fstream>

#include <functional>

#include <iostream>

#include <limits>

#include <map>

#include <numeric>

#include <queue>

#include <set>

#include <vector>

using namespace std;

using ll = long long;

#define fst first

#define snd second



/* clang-format off */

template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };

template <class T> struct _vec<T, 0> { using type = T; };

template <class T, size_t D> using vec = typename _vec<T, D>::type;

template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }

template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }

template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }

template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }

/* clang-format on */



template <std::uint_fast64_t Modulus>

class modint {

  using u64 = std::uint_fast64_t;



 public:

  u64 a;



  constexpr modint(const u64 x = 0) noexcept

      : a(x % Modulus) {

  }

  constexpr u64 &value() noexcept {

    return a;

  }

  constexpr const u64 &value() const noexcept {

    return a;

  }

  constexpr modint operator+(const modint rhs) const noexcept {

    return modint(*this) += rhs;

  }

  constexpr modint operator-(const modint rhs) const noexcept {

    return modint(*this) -= rhs;

  }

  constexpr modint operator*(const modint rhs) const noexcept {

    return modint(*this) *= rhs;

  }

  constexpr modint operator/(const modint rhs) const noexcept {

    return modint(*this) /= rhs;

  }

  constexpr modint &operator+=(const modint rhs) noexcept {

    a += rhs.a;

    if (a >= Modulus) {

      a -= Modulus;

    }

    return *this;

  }

  constexpr modint &operator-=(const modint rhs) noexcept {

    if (a < rhs.a) {

      a += Modulus;

    }

    a -= rhs.a;

    return *this;

  }

  constexpr modint &operator*=(const modint rhs) noexcept {

    a = a * rhs.a % Modulus;

    return *this;

  }

  constexpr modint &operator/=(const modint rhs) noexcept {

    return *this *= ~rhs;

  }

  constexpr modint operator^(u64 exp) const noexcept {

    modint v = 1, x = *this;

    while (exp) {

      if (exp & 1) {

        v *= x;

      }

      x *= x;

      exp >>= 1;

    }

    return v;

  }

  constexpr modint operator~() const noexcept {

    return *this ^ (Modulus - 2);

  }

};



using mint = modint<1000000007>;



vector<mint> fact, factInv;

void initFact(int N) {

  fact.resize(N + 1);

  factInv.resize(N + 1);

  fact[0] = 1;

  for (int i = 1; i <= N; i++) fact[i] = fact[i - 1] * i;

  factInv[N] = ~fact[N];

  for (int i = N - 1; i >= 0; i--) factInv[i] = factInv[i + 1] * (i + 1);

}



mint choose(int n, int k) {

  if (n < 0 || k < 0 || k > n) {

    return 0;

  } else {

    return fact[n] * factInv[k] * factInv[n - k];

  }

}



int main() {

#ifdef DEBUG

  ifstream ifs("in.txt");

  cin.rdbuf(ifs.rdbuf());

#endif

  int N, K;

  while (cin >> N >> K) {

    int L = N + 10;

    initFact(L);

    vec<mint, 2> f = make_v(L, L, mint(0));

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

      f[i][0] = 1;

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

        f[i][j] = f[i - 1][j] + f[i][j - 1];

      }

    }

    int bars = K - 1;

    int M = N - K;

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

      int b = i - 1;

      if (b > M) {

        cout << 0 << endl;

      } else {

        int dest = b + 2;

        mint res = choose(bars, b) * f[dest][M - b];

        cout << res.a << endl;

      }

    }

  }

  return 0;

}


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

#include <bitset>

#include <cassert>

#include <cctype>

#include <cmath>

#include <cstdint>

#include <cstdio>

#include <cstring>

#include <deque>

#include <fstream>

#include <functional>

#include <iostream>

#include <limits>

#include <map>

#include <numeric>

#include <queue>

#include <set>

#include <vector>

using namespace std;

using ll = long long;

#define fst first

#define snd second



/* clang-format off */

template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };

template <class T> struct _vec<T, 0> { using type = T; };

template <class T, size_t D> using vec = typename _vec<T, D>::type;

template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }

template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }

template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }

template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }

/* clang-format on */



template <std::uint_fast64_t Modulus>

class modint {

  using u64 = std::uint_fast64_t;



 public:

  u64 a;



  constexpr modint(const u64 x = 0) noexcept

      : a(x % Modulus) {

  }

  constexpr u64 &value() noexcept {

    return a;

  }

  constexpr const u64 &value() const noexcept {

    return a;

  }

  constexpr modint operator+(const modint rhs) const noexcept {

    return modint(*this) += rhs;

  }

  constexpr modint operator-(const modint rhs) const noexcept {

    return modint(*this) -= rhs;

  }

  constexpr modint operator*(const modint rhs) const noexcept {

    return modint(*this) *= rhs;

  }

  constexpr modint operator/(const modint rhs) const noexcept {

    return modint(*this) /= rhs;

  }

  constexpr modint &operator+=(const modint rhs) noexcept {

    a += rhs.a;

    if (a >= Modulus) {

      a -= Modulus;

    }

    return *this;

  }

  constexpr modint &operator-=(const modint rhs) noexcept {

    if (a < rhs.a) {

      a += Modulus;

    }

    a -= rhs.a;

    return *this;

  }

  constexpr modint &operator*=(const modint rhs) noexcept {

    a = a * rhs.a % Modulus;

    return *this;

  }

  constexpr modint &operator/=(const modint rhs) noexcept {

    return *this *= ~rhs;

  }

  constexpr modint operator^(u64 exp) const noexcept {

    modint v = 1, x = *this;

    while (exp) {

      if (exp & 1) {

        v *= x;

      }

      x *= x;

      exp >>= 1;

    }

    return v;

  }

  constexpr modint operator~() const noexcept {

    return *this ^ (Modulus - 2);

  }

};



using mint = modint<1000000007>;



vector<mint> fact, factInv;

void initFact(int N) {

  fact.resize(N + 1);

  factInv.resize(N + 1);

  fact[0] = 1;

  for (int i = 1; i <= N; i++) fact[i] = fact[i - 1] * i;

  factInv[N] = ~fact[N];

  for (int i = N - 1; i >= 0; i--) factInv[i] = factInv[i + 1] * (i + 1);

}



mint choose(int n, int k) {

  if (n < 0 || k < 0 || k > n) {

    return 0;

  } else {

    return fact[n] * factInv[k] * factInv[n - k];

  }

}



mint multiChoose(int n, int k) {

  if (n == 0 && k == 0) {

    return 1;

  } else {

    return choose(n + k - 1, k);

  }

}



int main() {

#ifdef DEBUG

  ifstream ifs("in.txt");

  cin.rdbuf(ifs.rdbuf());

#endif

  int N, K;

  while (cin >> N >> K) {

    int L = N + 10;

    initFact(N + 10);

    int bars = K - 1;

    int M = N - K;

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

      int b = i - 1;

      if (b > M) {

        cout << 0 << endl;

      } else {

        int rem = M - b;

        int dest = b + 2;

        mint res = choose(bars, b) * multiChoose(rem + 1, dest - 1);

        cout << res.a << endl;

      }

    }

  }

  return 0;

}


// Fastest known solution for this problem: