#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include <vector> 
#include <numeric>
#include <cmath>
#include <queue>


#define CHMAX(a,b) a = std::max(a,b)
#define CHMIN(a,b) a = std::min(a,b)
#define CHABS(a) a = std::abs(a) 
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std::cerr << a << std::endl
#define FOR(n) for(lli i = 0; i < n; i++)

using namespace std;
using lli = long long int;
using pll = pair<lli, lli>;
using tlll = tuple<lli, lli, lli>;

lli mod197 = 1000000007LL;

// ax + by = gcd(a,b) 最大公約数
template< typename T >
T extgcd(T a, T b, T& x, T& y) {
	T d = a;
	if (b != 0) {
		d = extgcd(b, a % b, y, x);
		y -= (a / b) * x;
	}
	else {
		x = 1;
		y = 0;
	}
	return d;
}

lli dp[2001][2001] = {};
lli combi[2001] = {};

template< int mod >
struct ModInt {
	int x;

	ModInt() : x(0) {}

	ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}

	ModInt& operator+=(const ModInt& p) {
		if ((x += p.x) >= mod) x -= mod;
		return *this;
	}

	ModInt& operator-=(const ModInt& p) {
		if ((x += mod - p.x) >= mod) x -= mod;
		return *this;
	}

	ModInt& operator*=(const ModInt& p) {
		x = (int)(1LL * x * p.x % mod);
		return *this;
	}

	ModInt& operator/=(const ModInt& p) {
		*this *= p.inverse();
		return *this;
	}

	ModInt operator-() const { return ModInt(-x); }

	ModInt operator+(const ModInt& p) const { return ModInt(*this) += p; }

	ModInt operator-(const ModInt& p) const { return ModInt(*this) -= p; }

	ModInt operator*(const ModInt& p) const { return ModInt(*this) *= p; }

	ModInt operator/(const ModInt& p) const { return ModInt(*this) /= p; }

	bool operator==(const ModInt& p) const { return x == p.x; }

	bool operator!=(const ModInt& p) const { return x != p.x; }

	ModInt inverse() const {
		int a = x, b = mod, u = 1, v = 0, t;
		while (b > 0) {
			t = a / b;
			swap(a -= t * b, b);
			swap(u -= t * v, v);
		}
		return ModInt(u);
	}

	ModInt pow(int64_t n) const {
		ModInt ret(1), mul(x);
		while (n > 0) {
			if (n & 1) ret *= mul;
			mul *= mul;
			n >>= 1;
		}
		return ret;
	}

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

	friend istream& operator>>(istream& is, ModInt& a) {
		int64_t t;
		is >> t;
		a = ModInt< mod >(t);
		return (is);
	}

	static int get_mod() { return mod; }
};

using modint = ModInt< 1000000007 >;


template< typename T >
struct Combination {
	vector< T > _fact, _rfact, _inv;

	Combination(int sz) : _fact(sz + 1), _rfact(sz + 1), _inv(sz + 1) {
		_fact[0] = _rfact[sz] = _inv[0] = 1;
		for (int i = 1; i <= sz; i++) _fact[i] = _fact[i - 1] * i;
		_rfact[sz] /= _fact[sz];
		for (int i = sz - 1; i >= 0; i--) _rfact[i] = _rfact[i + 1] * (i + 1);
		for (int i = 1; i <= sz; i++) _inv[i] = _rfact[i] * _fact[i - 1];
	}

	inline T fact(int k) const { return _fact[k]; }

	inline T rfact(int k) const { return _rfact[k]; }

	inline T inv(int k) const { return _inv[k]; }

	T P(int n, int r) const {
		if (r < 0 || n < r) return 0;
		return fact(n) * rfact(n - r);
	}

	T C(int p, int q) const {
		if (q < 0 || p < q) return 0;
		return fact(p) * rfact(q) * rfact(p - q);
	}

	T H(int n, int r) const {
		if (n < 0 || r < 0) return (0);
		return r == 0 ? 1 : C(n + r - 1, r);
	}
};

int main(void) {

	lli N, K;
	cin >> N >> K;

	lli R = N - K;
	lli B = K;

	if (R == 0 && B == 1) {
		COUT(1);
		return 0;
	}

	dp[1][B] = 1;

	for (int i = 2; i < N; i++) {
		for (int j = B - 1; j >= 1; j--) {
			dp[i][j] = dp[i - 1][j + 1] + dp[i][j + 1];
			dp[i][j] %= mod197;
		}
	}

	for (int i = 1; i < N; i++) {
		for (int j = B; j >= 0; j--) {
			combi[i] += dp[i][j];
			combi[i] %= mod197;
		}
	}

	modint ans = 0;

	Combination<modint> c(3000);

	for (int i = 1; i <= B; i++) {
		ans = c.C(R + 1, i) * modint(combi[i]);
		COUT(ans);
	}


	return 0;
}

Measured memory_bytes: 31488