using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Collections;
static class Extensions
{
    public static int ToInt(this string s) => int.Parse(s);
    public static long ToLong(this string s) => long.Parse(s);
    public static char ToChar(this string s) => char.Parse(s);
    public static double ToDouble(this string s) => double.Parse(s);
    public static int[] ToIntArray(this string s) => s.Replace(',', ' ').Split(' ').Select(x => x.ToInt()).ToArray();
    public static long[] ToLongArray(this string s) => s.Replace(',', ' ').Split(' ').Select(x => x.ToLong()).ToArray();
    public static double[] ToDoubleArray(this string s) => s.Replace(',', ' ').Split(' ').Select(x => x.ToDouble()).ToArray();
    public static Queue<T> ToQueue<T>(this IEnumerable<T> seq) => new Queue<T>(seq);
    public static Stack<T> ToStack<T>(this IEnumerable<T> seq) => new Stack<T>(seq);
    public static HashSet<T> ToHashSet<T>(this IEnumerable<T> seq) => new HashSet<T>(seq);
}
static class MyMath
{
    static private long gcdInner(long a, long b) => (a % b == 0) ? b : gcdInner(b, a % b);
    static public long GCD(long a, long b) => (a > b) ? gcdInner(a, b) : gcdInner(b, a);
    static public long LCM(long a, long b) => (a > b) ? (a / GCD(a, b) * b) : (b / GCD(a, b) * a);
}

class Program
{
    static string[] ReadLines(int n) => Enumerable.Range(0, n).Select(s => Console.ReadLine()).ToArray();

    static long mmmmmm = 1000000000 + 7;

    static void Main()
    {        
        
        //Nのかいじょうまでを計算できるようにしておく。
        //また、Nのかいじょうまでの逆元を計算できるようにしておく

        int[] nk = Console.ReadLine().ToIntArray();

        int N = nk[0];
        int K = nk[1];

        long[] Kaijou = new long[N + 1];
        long[] Gyaku = new long[N + 1];

        Kaijou[0] = 1;

        for(int i = 1; i <= N; i++)
        {
            Kaijou[i] = Kaijou[i - 1] * i;
            Kaijou[i] = mod(Kaijou[i], mmmmmm);
        }

        for(int i = 0; i <= N; i++)
        {
            Gyaku[i] = getGyakuGen(Kaijou[i], mmmmmm);
        }



        for(int i = 1; i <= K; i++)
        {
            if (i > N - K + 1)
            {
                Console.WriteLine(0);
                continue;
            }

            long ans = Kaijou[N - K + 1];
            ans = mod(ans, mmmmmm);
            ans *= Kaijou[K - 1];
            ans = mod(ans, mmmmmm);
            ans *= Gyaku[i];
            ans = mod(ans, mmmmmm);
            ans *= Gyaku[N - K + 1 - i];
            ans = mod(ans, mmmmmm);
            ans *= Gyaku[K - i];
            ans = mod(ans, mmmmmm);
            ans *= Gyaku[i - 1];
            ans = mod(ans, mmmmmm);

            Console.WriteLine(ans);
        }


    }

    static long getGyakuGen(long a, long m)
    {
        long x = 0;
        long y = 0;
        xxx(a, m, ref x, ref y);
        return mod(x, m);
    }

    static long xxx(long a, long b, ref long x, ref long y)
    {
        if (b == 0)
        {
            x = 1;
            y = 0;
            return a;
        }
        long d = xxx(b, a % b, ref y, ref x);
        y -= a / b * x;
        return d;
    }

    static long mod(long a, long m)
    {        
        return (a % m + m) % m;
    }
}

Measured memory_bytes: 13396