{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE RankNTypes #-}
{-# OPTIONS_GHC -O2 #-}

import GHC.TypeLits

import Data.Int
import Data.Proxy
import qualified Data.Map.Lazy as Map
import Data.List
import Data.Bits
import Data.Maybe
import qualified Data.ByteString.Char8 as BS
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.Array.IArray as Array
import Data.Array.MArray
import Data.Array.ST
--import Data.Monoid
--import Data.Semigroup

import Control.Applicative
import Control.Monad
import Control.Monad.ST
import Control.Monad.Primitive
import Control.Monad.State

import Debug.Trace




type M = Mint 1000000007

getInts :: IO [Int]
getInts = map (fst . fromJust . BS.readInt) . BS.words <$> BS.getLine

main :: IO ()
main = do
  [n, k] <- getInts

  let c = binomialTable 6000 6000 :: V.Vector (V.Vector M)

  let h n k
        | n == 0 && k == 0 = 1
        | n + k - 1 < 0 || k < 0 = 0
        | otherwise = c V.! (n + k - 1) V.! k

  --print c

  forM_ [1..k] $ \i -> do
    print $ getMintValue $ (c V.! (k-1) V.! (i-1)) * (h (i+1) (n-k-i+1))
    






{-- Mod Int --}
data Mint (m :: Nat) = Mint {getMintValue :: Integer} deriving (Eq, Show)

{-# INLINE getMintMod #-}
getMintMod :: forall p. KnownNat p => Mint p -> Integer
getMintMod = natVal

{-# INLINE makeMint #-}
makeMint :: forall p. KnownNat p => Integer -> Mint p
makeMint a
  | 0 <= a && a < p = Mint $ fromInteger $ a
  | otherwise = Mint $ fromInteger $ a `mod` p
  where p = natVal $ (Proxy :: Proxy p)

instance KnownNat p => Num (Mint p) where
  (Mint a) + (Mint b) = makeMint $ a + b
  (Mint a) - (Mint b) = makeMint $ a - b
  (Mint a) * (Mint b) = makeMint $ a * b
  negate (Mint a) = makeMint $ negate a
  abs = id
  signum (Mint a) = if a == 0 then 0 else 1
  fromInteger = makeMint


invMint :: forall p. KnownNat p => Mint p -> Mint p
invMint m = let p = getMintMod m in m ^ (p - 2)

powerMint :: forall p. KnownNat p => Integer -> Integer -> Mint p
powerMint n p
  | p >= 0 = (fromInteger n :: Mint p) ^ p
  | otherwise = invMint $ powerMint n (-p)



binomialTable :: Num a => Int -> Int -> V.Vector (V.Vector a)
binomialTable n m = ret
  where
    ret = V.generate (n+1) (\i -> V.generate (m+1) (\j -> f i j))
    f i j
      | i == 0 && j == 0 = 1
      | j == 0 = 1
      | i == 0 = 0
      | otherwise = (ret V.! (i-1) V.! (j-1)) + (ret V.! (i-1) V.! j)
