use std::io::Read;
use std::str::SplitWhitespace;
use std::str::FromStr;
use std::ops::{Add, Div, Mul};

const MODULO: u64 = 1_000_000_007;

#[derive(Copy, Clone)]
pub struct Rem {
    v: u64,
    modulo: u64,
}

pub struct CombTable {
    factorial: Vec<Rem>,
    fact_inv: Vec<Rem>,
}

impl CombTable {
    pub fn new(val: u64) -> Self {
        let n = val as usize;
        let mut v = Vec::with_capacity(n + 1);
        v.push(Rem::new(1));
        for i in 0..n {
            let prev = v[i];
            v.push(prev * Rem::new((i + 1) as u64));
        }

        let mut vi = vec![Rem::new(0); n + 1];
        vi[n] = v[n].pow(MODULO - 2);
        for i in 0..n {
            vi[n - i - 1] = vi[n - i] * Rem::new((n - i) as u64);
        }
        CombTable {
            factorial: v,
            fact_inv: vi,
        }
    }

    pub fn comb(&self, n: u64, r: u64) -> Rem {
        let nu = n as usize;
        let ru = r as usize;
        self.factorial[nu] * self.fact_inv[ru] * self.fact_inv[nu - ru]
    }
}

pub trait Modulo {
    fn new(x: u64) -> Self;
    fn with_modulo(x: u64, m: u64) -> Self;
    fn pow(&self, n: u64) -> Rem;
    fn to_u64(&self) -> u64;
}

impl Modulo for Rem {
    fn new(x: u64) -> Self {
        Rem {
            v: x,
            modulo: MODULO,
        }
    }

    fn with_modulo(x: u64, m: u64) -> Self {
        Rem { v: x, modulo: m }
    }

    fn pow(&self, n: u64) -> Rem {
        let mut remain_multiple_count = n;
        let mut base_square = Rem::new(self.v);
        let mut current = Rem::new(1);
        while remain_multiple_count > 0 {
            if remain_multiple_count & 1 == 1 {
                current = current * base_square;
            }
            base_square = base_square * base_square;
            remain_multiple_count /= 2;
        }
        current
    }

    fn to_u64(&self) -> u64 {
        self.v
    }
}

impl Div for Rem {
    type Output = Self;
    fn div(self, other: Self) -> Self::Output {
        assert!(self.modulo == other.modulo);
        self * other.pow(self.modulo - 2)
    }
}

impl Mul for Rem {
    type Output = Self;
    fn mul(self, other: Self) -> Self::Output {
        assert!(self.modulo == other.modulo);
        Rem::new(self.v * other.v % self.modulo)
    }
}

impl Add for Rem {
    type Output = Self;
    fn add(self, other: Self) -> Self::Output {
        assert!(self.modulo == other.modulo);
        Rem::new((self.v + other.v) % self.modulo)
    }
}

pub fn read_stdin() -> String {
    let mut s = String::new();
    ::std::io::stdin().read_to_string(&mut s).unwrap();
    s
}

pub trait Parse<T> {
    fn parse(&mut self) -> T;
}

impl<'a, T> Parse<T> for SplitWhitespace<'a>
where
    T: FromStr,
{
    fn parse(&mut self) -> T {
        let word = self.next().unwrap();
        word.parse().ok().unwrap()
    }
}

fn main() {
    let source = read_stdin();
    let mut iter = source.split_whitespace();
    let n: u64 = iter.parse();
    let k: u64 = iter.parse();

    let table = CombTable::new(n);
    let red_n = n - k;

    let ans = (0..k)
        .map(|i| if red_n < i {
            0
        } else {
            let rem = table.comb(red_n + 1, i + 1) * table.comb(k - 1, i);
            rem.to_u64()
        })
        .collect::<Vec<_>>();
    println!(
        "{}",
        ans.into_iter()
            .map(|x| x.to_string())
            .collect::<Vec<_>>()
            .join("\n")
    );
}

Measured memory_bytes: 4352