open System 

type Explicit =          
    static member inline ($) (_:int32, _:Explicit) = int
    static member inline ($) (_:int64, _:Explicit) = int64

let inline convert (value:'a): 'b = 
    (Unchecked.defaultof<'b> $ Unchecked.defaultof<Explicit>) value

let inline fromInt (x: int): 'a = convert x

module NumericLiteralG =
    let inline FromZero(): ^a = LanguagePrimitives.GenericZero
    let inline FromOne(): ^a = LanguagePrimitives.GenericOne
    let inline FromInt32 n = fromInt n

let inline extGcd (x: 'a) (y: 'a): 'a*'a*'a =
    let inline divRem x y = x / y, x % y 
    let rec f u v u' v' x y =
        if y = 0G then u, v, x 
        else let d, r = divRem x y in f u' v' (u - d * u') (v - d * v') y r 
    f 1G 0G 0G 1G x y 

let inline inverse (m: 'a) (x: 'a): 'a =
    extGcd x m 
    |> fun (x,_,_) -> (x + m) % m 
    
let inline combination (m: 'a) (size: int) : int -> int -> 'a =
    let facts, invFacts = 
        let facts = Array.zeroCreate <| size+1
        let invFacts = Array.zeroCreate <| size+1 
        facts.[0] <- 1G 
        invFacts.[0] <- inverse m facts.[0]
        for i in 1..size-1 do 
            facts.[i] <- fromInt i * facts.[i-1] % m
            invFacts.[i] <- inverse m facts.[i]
        facts, invFacts
    (fun n r -> 
        if n < 0 || r < 0 || n < r then failwithf "invalid arg, n: %d, r: %d" n r
        elif r = 0 || n = r then 1G
        elif n = 0 then 0G 
        else (facts.[n] * invFacts.[r] % m) * invFacts.[n-r] % m)
    
let MOD = int64 1e9 + 7L

let R() = Console.ReadLine()

let N, K = let t = R().Split() |> Array.map (string>>int) in int t.[0], int t.[1]

let comb = combination MOD N 

for i in 1..K do 
    if N - K + 1 < i then 0L
    else ((comb (N - K + 1) i) * (comb (K - 1) (i - 1))) % MOD
    |> Console.WriteLine