class Combination:
    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
    def __init__(self, n, mod):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % mod)
        self.inv_fact = [0] * (n + 1)
        self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
        for i in reversed(range(n)):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
        self.mod = mod

    def factorial(self, k):
        """k!を求める O(1)"""
        return self.fact[k]

    def inverse_factorial(self, k):
        """k!の逆元を求める O(1)"""
        return self.inv_fact[k]

    def permutation(self, k, r):
        """kPrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r]) % self.mod

    def combination(self, k, r):
        """kCrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod

    def combination_large(self, k, r):
        """kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
        if k < r:
            return 0
        res = 1
        for l in range(r):
            res *= (k - l)
            res %= self.mod
        return (res * self.inv_fact[r]) % self.mod

n,k = map(int,input().split())
mod = 10**9+7
comb = Combination(n,mod)

k = min(k,n-1)
ans = 0
for i in range(k+1):
    ans += comb.combination(n,i)*comb.combination(n-1,i)
    ans %= mod
print(ans) class Combination:
    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
    def __init__(self, n, mod):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % mod)
        self.inv_fact = [0] * (n + 1)
        self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
        for i in reversed(range(n)):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
        self.mod = mod

    def factorial(self, k):
        """k!を求める O(1)"""
        return self.fact[k]

    def inverse_factorial(self, k):
        """k!の逆元を求める O(1)"""
        return self.inv_fact[k]

    def permutation(self, k, r):
        """kPrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r]) % self.mod

    def combination(self, k, r):
        """kCrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod

    def combination_large(self, k, r):
        """kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
        if k < r:
            return 0
        res = 1
        for l in range(r):
            res *= (k - l)
            res %= self.mod
        return (res * self.inv_fact[r]) % self.mod Combination """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う""" def __init__(self, n, mod):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % mod)
        self.inv_fact = [0] * (n + 1)
        self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
        for i in reversed(range(n)):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
        self.mod = mod

     __init__ self.fact = [1] self.fact self fact [1] 1 for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % mod)
         i range(1, n + 1) range 1 n + 1 n 1 self.fact.append(self.fact[-1] * i % mod) self.fact.append self.fact self fact append self.fact[-1] * i % mod self.fact[-1] * i self.fact[-1] self.fact self fact -1 i mod self.inv_fact = [0] * (n + 1) self.inv_fact self inv_fact [0] * (n + 1) [0] 0 n + 1 n 1 self.inv_fact[n] = pow(self.fact[n], mod - 2, mod) self.inv_fact[n] self.inv_fact self inv_fact n pow(self.fact[n], mod - 2, mod) pow self.fact[n] self.fact self fact n mod - 2 mod 2 mod for i in reversed(range(n)):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
         i reversed(range(n)) reversed range(n) range n self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod self.inv_fact[i] self.inv_fact self inv_fact i self.inv_fact[i + 1] * (i + 1) % mod self.inv_fact[i + 1] * (i + 1) self.inv_fact[i + 1] self.inv_fact self inv_fact i + 1 i 1 i + 1 i 1 mod self.mod = mod self.mod self mod mod self self n n mod mod def factorial(self, k):
        """k!を求める O(1)"""
        return self.fact[k]

     factorial """k!を求める O(1)""" return self.fact[k] self.fact[k] self.fact self fact k self self k k def inverse_factorial(self, k):
        """k!の逆元を求める O(1)"""
        return self.inv_fact[k]

     inverse_factorial """k!の逆元を求める O(1)""" return self.inv_fact[k] self.inv_fact[k] self.inv_fact self inv_fact k self self k k def permutation(self, k, r):
        """kPrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r]) % self.mod

     permutation """kPrを求める O(1)""" if k < r:
            return 0
         k < r k r return 0 0 return (self.fact[k] * self.inv_fact[k - r]) % self.mod (self.fact[k] * self.inv_fact[k - r]) % self.mod self.fact[k] * self.inv_fact[k - r] self.fact[k] self.fact self fact k self.inv_fact[k - r] self.inv_fact self inv_fact k - r k r self.mod self mod self self k k r r def combination(self, k, r):
        """kCrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod

     combination """kCrを求める O(1)""" if k < r:
            return 0
         k < r k r return 0 0 return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r] self.fact[k] * self.inv_fact[k - r] self.fact[k] self.fact self fact k self.inv_fact[k - r] self.inv_fact self inv_fact k - r k r self.inv_fact[r] self.inv_fact self inv_fact r self.mod self mod self self k k r r def combination_large(self, k, r):
        """kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
        if k < r:
            return 0
        res = 1
        for l in range(r):
            res *= (k - l)
            res %= self.mod
        return (res * self.inv_fact[r]) % self.mod combination_large """kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用""" if k < r:
            return 0
         k < r k r return 0 0 res = 1 res 1 for l in range(r):
            res *= (k - l)
            res %= self.mod
         l range(r) range r res *= (k - l) res k - l k l res %= self.mod res self.mod self mod return (res * self.inv_fact[r]) % self.mod (res * self.inv_fact[r]) % self.mod res * self.inv_fact[r] res self.inv_fact[r] self.inv_fact self inv_fact r self.mod self mod self self k k r r n,k = map(int,input().split()) n map(int,input().split()) map int input().split() ().split () input split k mod = 10**9+7 mod 10**9+7 10**9 10 9 7 comb = Combination(n,mod) comb Combination(n,mod) Combination n mod k = min(k,n-1) k min(k,n-1) min k n-1 n 1 ans = 0 ans 0 for i in range(k+1):
    ans += comb.combination(n,i)*comb.combination(n-1,i)
    ans %= mod i range(k+1) range k+1 k 1 ans += comb.combination(n,i)*comb.combination(n-1,i) ans comb.combination(n,i)*comb.combination(n-1,i) comb.combination(n,i) comb.combination comb combination n i comb.combination(n-1,i) comb.combination comb combination n-1 n 1 i ans %= mod ans mod print(ans) print ans comb = Combination(n,mod) Combination(n,mod) comb k = map(int,input().split()) map(int,input().split()) k k = min(k,n-1) min(k,n-1) k n,k = map(int,input().split()) map(int,input().split()) n ans += comb.combination(n,i)*comb.combination(n-1,i) comb.combination(n,i)*comb.combination(n-1,i) ans ans %= mod mod ans ans = 0 0 ans mod = 10**9+7 10**9+7 mod class Combination:
    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
    def __init__(self, n, mod):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % mod)
        self.inv_fact = [0] * (n + 1)
        self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
        for i in reversed(range(n)):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
        self.mod = mod

    def factorial(self, k):
        """k!を求める O(1)"""
        return self.fact[k]

    def inverse_factorial(self, k):
        """k!の逆元を求める O(1)"""
        return self.inv_fact[k]

    def permutation(self, k, r):
        """kPrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r]) % self.mod

    def combination(self, k, r):
        """kCrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod

    def combination_large(self, k, r):
        """kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
        if k < r:
            return 0
        res = 1
        for l in range(r):
            res *= (k - l)
            res %= self.mod
        return (res * self.inv_fact[r]) % self.mod class Combination:
    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
    def __init__(self, n, mod):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % mod)
        self.inv_fact = [0] * (n + 1)
        self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
        for i in reversed(range(n)):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
        self.mod = mod

    def factorial(self, k):
        """k!を求める O(1)"""
        return self.fact[k]

    def inverse_factorial(self, k):
        """k!の逆元を求める O(1)"""
        return self.inv_fact[k]

    def permutation(self, k, r):
        """kPrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r]) % self.mod

    def combination(self, k, r):
        """kCrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod

    def combination_large(self, k, r):
        """kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
        if k < r:
            return 0
        res = 1
        for l in range(r):
            res *= (k - l)
            res %= self.mod
        return (res * self.inv_fact[r]) % self.mod Combination
class Combination:
    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
    def __init__(self, n, mod):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % mod)
        self.inv_fact = [0] * (n + 1)
        self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
        for i in reversed(range(n)):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
        self.mod = mod

    def factorial(self, k):
        """k!を求める O(1)"""
        return self.fact[k]

    def inverse_factorial(self, k):
        """k!の逆元を求める O(1)"""
        return self.inv_fact[k]

    def permutation(self, k, r):
        """kPrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r]) % self.mod

    def combination(self, k, r):
        """kCrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod

    def combination_large(self, k, r):
        """kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
        if k < r:
            return 0
        res = 1
        for l in range(r):
            res *= (k - l)
            res %= self.mod
        return (res * self.inv_fact[r]) % self.mod

n,k = map(int,input().split())
mod = 10**9+7
comb = Combination(n,mod)

k = min(k,n-1)
ans = 0
for i in range(k+1):
    ans += comb.combination(n,i)*comb.combination(n-1,i)
    ans %= mod
print(ans)