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: class Mint:
      MOD = 1000000007  # Must be a prime
      CACHE_FACTORIALS = [1, 1]
  
      def __init__(self, v):
          if self.__isally(v):
              self.v = v.v
          else:
              self.v = v % self.MOD
  
      @property
      def inv(self):
          return Mint(self.__minv(self.v))
  
      @classmethod
      def factorial(cls, v):
          for i in range(len(cls.CACHE_FACTORIALS), int(v) + 1):
              cls.CACHE_FACTORIALS.append(cls.CACHE_FACTORIALS[-1] * i % cls.MOD)
          return Mint(cls.CACHE_FACTORIALS[int(v)])
  
      @classmethod
      def perm(cls, n, r):
          if n < r or r < 0:
              return 0
          return cls.factorial(n) // cls.factorial(n - r)
  
      @classmethod
      def comb(cls, n, r):
          if n < r or r < 0:
              return 0
          return cls.perm(n, r) // cls.factorial(r)
  
      @classmethod
      def __isally(cls, v) -> bool:
          return isinstance(v, cls)
  
      @classmethod
      def __minv(cls, v) -> int:
          return pow(v, cls.MOD - 2, cls.MOD)
  
      @classmethod
      def __mpow(cls, v, w) -> int:
          return pow(v, w, cls.MOD)
  
      def __str__(self):
          return str(self.v)
  
      __repr__ = __str__
  
      def __int__(self):
          return self.v
  
      def __eq__(self, w):
          return self.v == w.v if self.__isally(w) else self.v == w
  
      def __add__(self, w):
          return Mint(self.v + w.v) if self.__isally(w) else Mint(self.v + w)
  
      __radd__ = __add__
  
      def __sub__(self, w):
          return Mint(self.v - w.v) if self.__isally(w) else Mint(self.v - w)
  
      def __rsub__(self, u):
          return Mint(u.v - self.v) if self.__isally(u) else Mint(u - self.v)
  
      def __mul__(self, w):
          return Mint(self.v * w.v) if self.__isally(w) else Mint(self.v * w)
  
      __rmul__ = __mul__
  
      def __floordiv__(self, w):
          return (
              Mint(self.v * self.__minv(w.v))
              if self.__isally(w)
              else Mint(self.v * self.__minv(w))
          )
  
      def __rfloordiv__(self, u):
          return (
              Mint(u.v * self.__minv(self.v))
              if self.__isally(u)
              else Mint(u * self.__minv(self.v))
          )
  
      def __pow__(self, w):
          return (
              Mint(self.__mpow(self.v, w.v))
              if self.__isally(w)
              else Mint(self.__mpow(self.v, w))
          )
  
      def __rpow__(self, u):
          return (
              Mint(self.__mpow(u.v, self.v))
              if self.__isally(u)
              else Mint(self.__mpow(u, self.v))
          )
  
  
  n, k = map(int, input().split())
  for i in range(1, k + 1):
      print(Mint.comb(n - k + 1, i) * Mint.comb(k - 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."}]