local read = setmetatable({}, {__index = function(t, k) local a = {} for i=1,#k do table.insert(a, '*'..string.sub(k, i, i)) end local r = io.read local u = table.unpack or unpack return function() return r(u(a)) end end})
read.N = function(N) local t={} for i=1,N do t[i]=read.n() end return t end
string.totable = function(s) local t={} local u=string.sub for i=1,#s do t[i] = u(s, i, i) end return t end
string.split = function(s) local t={} for w in string.gmatch(s, "[^%s]+") do table.insert(t, w) end return (table.unpack or unpack)(t) end
local function array(dimension, default_val) local n=dimension local m={}if default_val~=nil then m[1]={__index=function()return default_val end}end for i=2,n do m[i]={__index=function(p, k)local c=setmetatable({},m[i-1])rawset(p,k,c)return c end}end return setmetatable({},m[n])end
----
-- returns (b^n) % m
local function modpow(b, n, m)
    if n == 0 then
        return 1
    elseif n % 2 == 0 then
        -- be careful about overflow of b*b
        return modpow(b * b % m, n//2, m)
    else
        return b * modpow(b, n - 1, m) % m
    end
end

-- returns n! % m
local function modfactorial(n, m)
    local a = 1
    for i=1, n do
        a = a * i % m
    end
    return a
end

local function make_mod_nCr(nmax, m)
    -- Create n! table
    local mfac = {}
    mfac[0] = 1
    for i=1,nmax do
        mfac[i] = mfac[i-1] * i % m
    end
    -- Create (n!)^(-1) table
    -- (n!)^(-1) ≡ (n!)^(m - 2)  <mod m>
    local invmfac = {}
    invmfac[nmax] = modpow(mfac[nmax], m - 2, m)
    for i=nmax,0,-1 do
        -- ((a-1)!)^(-1) ≡ a * (a!)^(-1)  <mod m>
        invmfac[i-1] = i * invmfac[i] % m
    end
    -- returns nCr % m
    local function mod_nCr(n, r)
        if r > n then
            return 0
        end
        if r > n/2 then
            r = n - r
        end
        if not mfac[n] or not invmfac[r] or not invmfac[n-r] then
            print("n=",n,"mfac[n]",mfac[n])
            print("r=",r,"invmfac[r]",invmfac[r])
            print("n-r=",r,"invmfac[n-r]",invmfac[n-r])
            error()
        end
        -- nCr ≡ n! * (r!)^(-1) * ((n-r)!)^(-1)  <mod m>
        local a = mfac[n] * invmfac[r] % m
        a = a * invmfac[n-r] % m
        return a
    end
    return mod_nCr
end


-- larger n and small r
local function make_mod_nCr_2(rmax, m)
    -- Create n! table
    local mfac = {}
    mfac[0] = 1
    for i=1,rmax do
        mfac[i] = mfac[i-1] * i % m
    end
    -- Create (n!)^(-1) table
    -- (n!)^(-1) ≡ (n!)^(m - 2)  <mod m>
    local invmfac = {}
    invmfac[rmax] = modpow(mfac[rmax], m - 2, m)
    for i=rmax,1,-1 do
        -- ((a-1)!)^(-1) ≡ a * (a!)^(-1)  <mod m>
        invmfac[i-1] = i * invmfac[i] % m
    end
    -- returns nCr % m
    local function mod_nCr(n, r)
        if r > n then
            return 0
        end
        if r > n/2 then
            r = n - r
        end
        -- nCr ≡ (n * (n - 1) * ... * (n-r+1)) * (r!)^(-1)  <mod m>
        local a = 1
        for i=n, n-r+1, -1 do
            a = (a * i) % m
        end
        a = a * invmfac[r] % m
        return a
    end
    return mod_nCr
end

----
local MOD = math.floor(10^9)+7
local N, K = read.nn()
local L = N - K

local nCr = make_mod_nCr(N, MOD)

local function f(x, y)
    return nCr(y-1, x-1)
end

local function solve(i)
    if i == 1 then
        local blue = 1
        local red = nCr(L+1,1)
        return (blue * red) % MOD
    else
        local blue = f(i, K)
        local red = 0
        red = (red + f(i-1, N-K)) % MOD
        red = (red + (2 * f(i, N-K) % MOD)) % MOD
        red = (red + f(i+1, N-K)) % MOD
        return (blue * red) % MOD
    end
end

for i=1,K do
    print(solve(i))
end