output_description: Print the number of possible combinations of numbers of people in the n rooms
  now, modulo (10^9 + 7).
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      n k
attempt: MOD = 10**9 + 7
  
  
  class Fp(int):
      def __new__(self, x=0):
          return super().__new__(self, x % MOD)
  
      def inv(self):
          return self.__class__(super().__pow__(MOD - 2, MOD))
  
      def __add__(self, value):
          return self.__class__(super().__add__(value))
  
      def __sub__(self, value):
          return self.__class__(super().__sub__(value))
  
      def __mul__(self, value):
          return self.__class__(super().__mul__(value))
  
      def __floordiv__(self, value):
          return self.__class__(self * self.__class__(value).inv())
  
      def __pow__(self, value):
          return self.__class__(super().__pow__(value % (MOD - 1), MOD))
  
      __radd__ = __add__
      __rmul__ = __mul__
  
      def __rsub__(self, value):
          return self.__class__(-super().__sub__(value))
  
      def __rfloordiv__(self, value):
          return self.__class__(self.inv() * value)
  
      def __iadd__(self, value):
          self = self + value
          return self
  
      def __isub__(self, value):
          self = self - value
          return self
  
      def __imul__(self, value):
          self = self * value
          return self
  
      def __ifloordiv__(self, value):
          self = self // value
          return self
  
      def __ipow__(self, value):
          self = self**value
          return self
  
      def __neg__(self):
          return self.__class__(super().__neg__())
  
  
  class Combination:
      def __init__(self, max_n):
          self.max_n = 0
          self.fact = [Fp(1)]
          self.ifact = [Fp(1)]
          self.make_fact_list(max_n)
  
      def C(self, n, k):
          return self.fact[n] * self.ifact[k] * self.ifact[n - k] if 0 <= k <= n else 0
  
      def H(self, n, k):
          return self.C(n + k - 1, k) if n or k else 1
  
      def P(self, n, k):
          return self.fact[n] * self.ifact[n - k] if 0 <= k <= n else 0
  
      def make_fact_list(self, max_n):
          if max_n <= self.max_n:
              return
          self.fact += [Fp(0)] * (max_n - self.max_n)
          self.ifact += [Fp(0)] * (max_n - self.max_n)
          for i in range(self.max_n + 1, max_n + 1):
              self.fact[i] = self.fact[i - 1] * i
              self.ifact[i] = self.ifact[i - 1] // i
          self.max_n = max_n
  
  
  N, K = map(int, input().split())
  K = min(N - 1, K)
  C = Combination(N * 2)
  ans = Fp(1)
  for i in range(1, K + 1):
      ans += C.C(N, i) * C.H(N - i, i)
  print(ans)
  
problem_description: Statement
  
  There is a building with n rooms, numbered 1 to n.
  
  We can move from any room to any other room in the building.
  
  Let us call the following event a **move** : a person in some room i goes to
  another room j~ (i \neq j).
  
  Initially, there was one person in each room in the building.
  
  After that, we know that there were exactly k moves happened up to now.
  
  We are interested in the number of people in each of the n rooms now. How many
  combinations of numbers of people in the n rooms are possible?
  
  Find the count modulo (10^9 + 7).
samples: [{"input": "3 2", "output": "10\n    \n\nLet c_1, c_2, and c_3 be the number of people in Room 1, 2, and 3 now,\nrespectively. There are 10 possible combination of (c_1, c_2, c_3):\n\n  * (0, 0, 3)\n  * (0, 1, 2)\n  * (0, 2, 1)\n  * (0, 3, 0)\n  * (1, 0, 2)\n  * (1, 1, 1)\n  * (1, 2, 0)\n  * (2, 0, 1)\n  * (2, 1, 0)\n  * (3, 0, 0)\n\nFor example, (c_1, c_2, c_3) will be (0, 1, 2) if the person in Room 1 goes to\nRoom 2 and then one of the persons in Room 2 goes to Room 3.\n\n* * *"}, {"input": "200000 1000000000", "output": "607923868\n    \n\nPrint the count modulo (10^9 + 7).\n\n* * *"}, {"input": "15 6", "output": "22583772"}]