output_description: Print K lines. The i-th line (1 \leq i \leq K) should contain the number of
  ways to arrange the N balls so that Takahashi will need exactly i moves to
  collect all the blue balls, modulo 10^9+7.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
attempt: import sys
  
  sys.setrecursionlimit(200000)
  input = sys.stdin.readline
  
  
  def ii():
      return int(input())
  
  
  def mi():
      return map(int, input().rstrip().split())
  
  
  def lmi():
      return list(map(int, input().rstrip().split()))
  
  
  def li():
      return list(input().rstrip())
  
  
  # template
  
  
  # BEGIN CUT HERE
  MOD = 10**9 + 7
  
  
  class Modint:
      """
      自動でMODで割った余りを返してくれる。
      """
  
      def __init__(self, n, mod=MOD):
          if n >= 0:
              self.n = n % mod
          else:
              self.n = (mod - (-n) % mod) % mod
          self.mod = mod
  
      def __eq__(self, other):
          return self.n == int(other)
  
      def __ne__(self, other):
          return not self == other
  
      def __neg__(self):
          return Modint(-self.n, self.mod)
  
      def __str__(self):
          return str(self.n)
  
      def __int__(self):
          return int(self.n)
  
      def __iadd__(self, other):
          self.n += int(other)
          self.n %= self.mod
          return self
  
      def __radd__(self, other):
          self.n += int(other)
          self.n %= self.mod
          return self
  
      def __isub__(self, other):
          self.n -= int(other)
          self.n %= self.mod
          return self
  
      def __rsub__(self, other):
          self.n -= int(other)
          self.n %= self.mod
          return self
  
      def __imul__(self, other):
          self.n = self.n * int(other) % self.mod
          return self
  
      def __rmul__(self, other):
          self.n = self.n * int(other) % self.mod
          return self
  
      def inverse(self):
          return self.__class__(pow(self.n, self.mod - 2, self.mod), self.mod)
  
      def __ifloordiv__(self, other):
          self *= pow(int(other), self.mod - 2, self.mod)
          return self
  
      def __rfloordiv__(self, other):
          self *= pow(int(other), self.mod - 2, self.mod)
          return self
  
      def __add__(self, other):
          self += other
          return self
  
      def __sub__(self, other):
          self -= other
          return self
  
      def __mul__(self, other):
          self *= other
          return self
  
      def __floordiv__(self, other):
          self //= other
          return self
  
      """コンビネーション絡みの定義
          ･ comb(n,k):特に前処理をせずnCkを求める
      """
  
      def comb(self, n, k):
          if n < k or k < 0:
              return Modint(0)
          res = Modint(1)
          for i in range(int(k)):
              res *= Modint(n - i)
              res //= Modint(i + 1)
          return res
  
      def H(self, n, k):
          if n < 0 or k < 0:
              return Modint(0)
          elif n == 0 and k == 0:
              return Modint(1)
          else:
              return self.comb(n + k - 1, n)
  
  
  if __name__ == "__main__":
      N, K = mi()
      res = Modint(0)
      for i in range(1, K + 1):
          print(res.comb(K - 1, i - 1) * res.H(N - K - i + 1, i + 1))
  
problem_description: Statement
  
  There are K blue balls and N-K red balls. The balls of the same color cannot
  be distinguished. Snuke and Takahashi are playing with these balls.
  
  First, Snuke will arrange the N balls in a row from left to right.
  
  Then, Takahashi will collect only the K blue balls. In one move, he can
  collect any number of consecutive blue balls. He will collect all the blue
  balls in the fewest moves possible.
  
  How many ways are there for Snuke to arrange the N balls in a row so that
  Takahashi will need exactly i moves to collect all the blue balls? Compute
  this number modulo 10^9+7 for each i such that 1 \leq i \leq K.
samples: [{"input": "5 3", "output": "3\n    6\n    1\n    \n\nThere are three ways to arrange the balls so that Takahashi will need exactly\none move: (B, B, B, R, R), (R, B, B, B, R), and (R, R, B, B, B). (R and B\nstands for red and blue, respectively).\n\nThere are six ways to arrange the balls so that Takahashi will need exactly\ntwo moves: (B, B, R, B, R), (B, B, R, R, B), (R, B, B, R, B), (R, B, R, B, B),\n(B, R, B, B, R), and (B, R, R, B, B).\n\nThere is one way to arrange the balls so that Takahashi will need exactly\nthree moves: (B, R, B, R, B).\n\n* * *"}, {"input": "2000 3", "output": "1998\n    3990006\n    327341989\n    \n\nBe sure to print the numbers of arrangements modulo 10^9+7."}]