#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2>
inline void chmin(T1& a, T2 b) {
  if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1& a, T2 b) {
  if (a < b) a = b;
}

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_identity() { return Mint(1); }

  Mint inv() { return pow(MOD - 2); }

  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; }

  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;
}

template <typename M>
class Enumeration {
 private:
  static vector<M> fact, finv, invs;

 public:
  static void init(Int n) {
    n = min<decltype(M::mod)>(n, M::mod - 1);

    Int m = fact.size();
    if (n < m) return;

    fact.resize(n + 1, 1);
    finv.resize(n + 1, 1);
    invs.resize(n + 1, 1);

    if (m == 0) m = 1;
    for (Int i = m; i <= n; i++) fact[i] = fact[i - 1] * M(i);
    finv[n] = M(1) / fact[n];
    for (Int i = n; i >= m; i--) finv[i - 1] = finv[i] * M(i);
    for (Int i = m; i <= n; i++) invs[i] = finv[i] * fact[i - 1];
  }

  static M Fact(Int n) {
    init(n);
    return fact[n];
  }
  static M Finv(Int n) {
    init(n);
    return finv[n];
  }
  static M Invs(Int n) {
    init(n);
    return invs[n];
  }

  static M C(Int n, Int k) {
    if (n < k || k < 0) return M(0);
    init(n);
    return fact[n] * finv[n - k] * finv[k];
  }

  static M P(Int n, Int k) {
    if (n < k || k < 0) return M(0);
    init(n);
    return fact[n] * finv[n - k];
  }

  static M H(Int n, Int k) {
    if (n < 0 || k < 0) return M(0);
    if (!n && !k) return M(1);
    init(n + k - 1);
    return C(n + k - 1, k);
  }

  static M S(Int n, Int k) {
    M res;
    init(k);
    for (Int i = 1; i <= k; i++) {
      M tmp = C(k, i) * M(i).pow(n);
      if ((k - i) & 1)
        res -= tmp;
      else
        res += tmp;
    }
    return res *= finv[k];
  }

  static vector<vector<M> > D(Int n, Int m) {
    vector<vector<M> > dp(n + 1, vector<M>(m + 1, 0));
    dp[0][0] = M(1);
    for (Int i = 0; i <= n; i++) {
      for (Int j = 1; j <= m; j++) {
        if (i - j >= 0)
          dp[i][j] = dp[i][j - 1] + dp[i - j][j];
        else
          dp[i][j] = dp[i][j - 1];
      }
    }
    return dp;
  }

  static M B(Int n, Int k) {
    if (n == 0) return M(1);
    k = min(k, n);
    init(k);
    vector<M> dp(k + 1);
    dp[0] = M(1);
    for (Int i = 1; i <= k; i++)
      dp[i] = dp[i - 1] + ((i & 1) ? -finv[i] : finv[i]);
    M res;
    for (Int i = 1; i <= k; i++) res += M(i).pow(n) * finv[i] * dp[k - i];
    return res;
  }

  static M montmort(Int n) {
    M res;
    init(n);
    for (Int k = 2; k <= n; k++) {
      if (k & 1)
        res -= finv[k];
      else
        res += finv[k];
    }
    return res *= fact[n];
  }

  static M LagrangePolynomial(vector<M>& y, M t) {
    Int n = y.size() - 1;
    if (t.v <= n) return y[t.v];
    init(n + 1);
    vector<M> dp(n + 1, 1), pd(n + 1, 1);
    for (Int i = 0; i < n; i++) dp[i + 1] = dp[i] * (t - M(i));
    for (Int i = n; i > 0; i--) pd[i - 1] = pd[i] * (t - M(i));
    M res{0};
    for (Int i = 0; i <= n; i++) {
      M tmp = y[i] * dp[i] * pd[i] * finv[i] * finv[n - i];
      if ((n - i) & 1)
        res -= tmp;
      else
        res += tmp;
    }
    return res;
  }
};
template <typename M>
vector<M> Enumeration<M>::fact = vector<M>();
template <typename M>
vector<M> Enumeration<M>::finv = vector<M>();
template <typename M>
vector<M> Enumeration<M>::invs = vector<M>();

int main() {
  Int n, k;
  cin >> n >> k;
  Int x = n - k;

  using M = Mint<Int>;
  using E = Enumeration<M>;
  E::init(1e5);

  for (Int i = 1; i <= k; i++) cout << E::C(x + 1, i) * E::H(i, k - i) << endl;

  return 0;
}


Measured memory_bytes: 5616