import sys
from io import StringIO
import unittest
import os

# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)


def prepare(n, mod=pow(10, 9) + 7):
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= mod
        factorials.append(f)
    inv = pow(f, mod - 2, mod)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= mod
        invs[m - 1] = inv

    return factorials, invs


# 実装を行う関数
def resolve(test_def_name=""):
    n, k = map(int, input().split())

    # 逆数を求める
    fns, invs = prepare(pow(10, 6))

    # 計算
    ans = 0
    for i in range(1, min(n - 1, k) + 1):
        # (fns[n] * invs[i] * invs[n - i]) 0の部屋パターン数
        # (fns[n - 1] * invs[i] * invs[n - 1 - i])  移動先数(重複組み合わせで求める。)
        ans += (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7)
        ans = ans % (pow(10, 9) + 7)

    # ALL1のパターンを考慮して+1した結果を出力。
    print(ans + 1)


# テストクラス
class TestClass(unittest.TestCase):
    def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

    def test_input_1(self):
        test_input = """3 2"""
        output = """10"""
        self.assertIO(test_input, output)

    def test_input_2(self):
        test_input = """200000 1000000000"""
        output = """607923868"""
        self.assertIO(test_input, output)

    def test_input_3(self):
        test_input = """15 6"""
        output = """22583772"""
        self.assertIO(test_input, output)

    # 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
    def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)


# 実装orテストの呼び出し
if __name__ == "__main__":
    if os.environ.get("USERNAME") is None:
        # AtCoder提出時の場合
        resolve()

    else:
        # 自PCの場合
        unittest.main() import sys sys from io import StringIO import unittest unittest import os os sys.setrecursionlimit(999999999) sys.setrecursionlimit sys setrecursionlimit 999999999 def prepare(n, mod=pow(10, 9) + 7):
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= mod
        factorials.append(f)
    inv = pow(f, mod - 2, mod)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= mod
        invs[m - 1] = inv

    return factorials, invs


# 実装を行う関数 prepare f = 1 f 1 factorials = [1] factorials [1] 1 for m in range(1, n + 1):
        f *= m
        f %= mod
        factorials.append(f)
     m range(1, n + 1) range 1 n + 1 n 1 f *= m f m f %= mod f mod factorials.append(f) factorials.append factorials append f inv = pow(f, mod - 2, mod) inv pow(f, mod - 2, mod) pow f mod - 2 mod 2 mod invs = [1] * (n + 1) invs [1] * (n + 1) [1] 1 n + 1 n 1 invs[n] = inv invs[n] invs n inv for m in range(n, 1, -1):
        inv *= m
        inv %= mod
        invs[m - 1] = inv

     m range(n, 1, -1) range n 1 -1 inv *= m inv m inv %= mod inv mod invs[m - 1] = inv invs[m - 1] invs m - 1 m 1 inv return factorials, invs return factorials, invs factorials invs n n mod=pow(10, 9) + 7 mod pow(10, 9) + 7 pow(10, 9) pow 10 9 7 def resolve(test_def_name=""):
    n, k = map(int, input().split())

    # 逆数を求める
    fns, invs = prepare(pow(10, 6))

    # 計算
    ans = 0
    for i in range(1, min(n - 1, k) + 1):
        # (fns[n] * invs[i] * invs[n - i]) 0の部屋パターン数
        # (fns[n - 1] * invs[i] * invs[n - 1 - i])  移動先数(重複組み合わせで求める。)
        ans += (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7)
        ans = ans % (pow(10, 9) + 7)

    # ALL1のパターンを考慮して+1した結果を出力。
    print(ans + 1)


# テストクラス resolve n, k = map(int, input().split()) n map(int, input().split()) map int input().split() ().split () input split k fns, invs = prepare(pow(10, 6)) fns prepare(pow(10, 6)) prepare pow(10, 6) pow 10 6 invs ans = 0 ans 0 for i in range(1, min(n - 1, k) + 1):
        # (fns[n] * invs[i] * invs[n - i]) 0の部屋パターン数
        # (fns[n - 1] * invs[i] * invs[n - 1 - i])  移動先数(重複組み合わせで求める。)
        ans += (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7)
        ans = ans % (pow(10, 9) + 7)

    # ALL1のパターンを考慮して+1した結果を出力。
     i range(1, min(n - 1, k) + 1) range 1 min(n - 1, k) + 1 min(n - 1, k) min n - 1 n 1 k 1 ans += (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7) ans (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7) (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) fns[n] * invs[i] * invs[n - i] fns[n] * invs[i] fns[n] fns n invs[i] invs i invs[n - i] invs n - i n i fns[n - 1] * invs[i] * invs[n - 1 - i] fns[n - 1] * invs[i] fns[n - 1] fns n - 1 n 1 invs[i] invs i invs[n - 1 - i] invs n - 1 - i n - 1 n 1 i pow(10, 9) + 7 pow(10, 9) pow 10 9 7 ans = ans % (pow(10, 9) + 7) ans ans % (pow(10, 9) + 7) ans pow(10, 9) + 7 pow(10, 9) pow 10 9 7 print(ans + 1) print ans + 1 ans 1 test_def_name="" test_def_name "" class TestClass(unittest.TestCase):
    def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

    def test_input_1(self):
        test_input = """3 2"""
        output = """10"""
        self.assertIO(test_input, output)

    def test_input_2(self):
        test_input = """200000 1000000000"""
        output = """607923868"""
        self.assertIO(test_input, output)

    def test_input_3(self):
        test_input = """15 6"""
        output = """22583772"""
        self.assertIO(test_input, output)

    # 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
    def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)


# 実装orテストの呼び出し TestClass def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

     assertIO stdout, sat_in = sys.stdout, sys.stdin stdout sys.stdout sys stdout sat_in sys.stdin sys stdin sys.stdout, sys.stdin = StringIO(), StringIO(assert_input) sys.stdout sys stdout StringIO() StringIO sys.stdin sys stdin StringIO(assert_input) StringIO assert_input resolve(sys._getframe().f_back.f_code.co_name) resolve sys._getframe().f_back.f_code.co_name sys._getframe().f_back.f_code sys._getframe().f_back sys._getframe() sys._getframe sys _getframe f_back f_code co_name sys.stdout.seek(0) sys.stdout.seek sys.stdout sys stdout seek 0 out = sys.stdout.read()[:-1] out sys.stdout.read()[:-1] sys.stdout.read() sys.stdout.read sys.stdout sys stdout read :-1 -1 sys.stdout, sys.stdin = stdout, sat_in sys.stdout sys stdout stdout sys.stdin sys stdin sat_in self.assertEqual(out, output) self.assertEqual self assertEqual out output self self assert_input assert_input output output def test_input_1(self):
        test_input = """3 2"""
        output = """10"""
        self.assertIO(test_input, output)

     test_input_1 test_input = """3 2""" test_input """3 2""" output = """10""" output """10""" self.assertIO(test_input, output) self.assertIO self assertIO test_input output self self def test_input_2(self):
        test_input = """200000 1000000000"""
        output = """607923868"""
        self.assertIO(test_input, output)

     test_input_2 test_input = """200000 1000000000""" test_input """200000 1000000000""" output = """607923868""" output """607923868""" self.assertIO(test_input, output) self.assertIO self assertIO test_input output self self def test_input_3(self):
        test_input = """15 6"""
        output = """22583772"""
        self.assertIO(test_input, output)

    # 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
     test_input_3 test_input = """15 6""" test_input """15 6""" output = """22583772""" output """22583772""" self.assertIO(test_input, output) self.assertIO self assertIO test_input output self self def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)


# 実装orテストの呼び出し tes_t_1original_1 test_input = """データ""" test_input """データ""" output = """データ""" output """データ""" self.assertIO(test_input, output) self.assertIO self assertIO test_input output self self unittest.TestCase unittest TestCase if __name__ == "__main__":
    if os.environ.get("USERNAME") is None:
        # AtCoder提出時の場合
        resolve()

    else:
        # 自PCの場合
        unittest.main() __name__ == "__main__" __name__ "__main__" if os.environ.get("USERNAME") is None:
        # AtCoder提出時の場合
        resolve()

    else:
        # 自PCの場合
        unittest.main() os.environ.get("USERNAME") is None os.environ.get("USERNAME") os.environ.get os.environ os environ get "USERNAME" None resolve() resolve unittest.main() unittest.main unittest main def prepare(n, mod=pow(10, 9) + 7):
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= mod
        factorials.append(f)
    inv = pow(f, mod - 2, mod)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= mod
        invs[m - 1] = inv

    return factorials, invs


# 実装を行う関数 def prepare(n, mod=pow(10, 9) + 7):
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= mod
        factorials.append(f)
    inv = pow(f, mod - 2, mod)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= mod
        invs[m - 1] = inv

    return factorials, invs


# 実装を行う関数 prepare def resolve(test_def_name=""):
    n, k = map(int, input().split())

    # 逆数を求める
    fns, invs = prepare(pow(10, 6))

    # 計算
    ans = 0
    for i in range(1, min(n - 1, k) + 1):
        # (fns[n] * invs[i] * invs[n - i]) 0の部屋パターン数
        # (fns[n - 1] * invs[i] * invs[n - 1 - i])  移動先数(重複組み合わせで求める。)
        ans += (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7)
        ans = ans % (pow(10, 9) + 7)

    # ALL1のパターンを考慮して+1した結果を出力。
    print(ans + 1)


# テストクラス def resolve(test_def_name=""):
    n, k = map(int, input().split())

    # 逆数を求める
    fns, invs = prepare(pow(10, 6))

    # 計算
    ans = 0
    for i in range(1, min(n - 1, k) + 1):
        # (fns[n] * invs[i] * invs[n - i]) 0の部屋パターン数
        # (fns[n - 1] * invs[i] * invs[n - 1 - i])  移動先数(重複組み合わせで求める。)
        ans += (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7)
        ans = ans % (pow(10, 9) + 7)

    # ALL1のパターンを考慮して+1した結果を出力。
    print(ans + 1)


# テストクラス resolve class TestClass(unittest.TestCase):
    def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

    def test_input_1(self):
        test_input = """3 2"""
        output = """10"""
        self.assertIO(test_input, output)

    def test_input_2(self):
        test_input = """200000 1000000000"""
        output = """607923868"""
        self.assertIO(test_input, output)

    def test_input_3(self):
        test_input = """15 6"""
        output = """22583772"""
        self.assertIO(test_input, output)

    # 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
    def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)


# 実装orテストの呼び出し class TestClass(unittest.TestCase):
    def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

    def test_input_1(self):
        test_input = """3 2"""
        output = """10"""
        self.assertIO(test_input, output)

    def test_input_2(self):
        test_input = """200000 1000000000"""
        output = """607923868"""
        self.assertIO(test_input, output)

    def test_input_3(self):
        test_input = """15 6"""
        output = """22583772"""
        self.assertIO(test_input, output)

    # 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
    def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)


# 実装orテストの呼び出し TestClass
import sys
from io import StringIO
import unittest
import os

# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)


def prepare(n, mod=pow(10, 9) + 7):
    f = 1
    factorials = [1]
    for m in range(1, n + 1):
        f *= m
        f %= mod
        factorials.append(f)
    inv = pow(f, mod - 2, mod)
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= mod
        invs[m - 1] = inv

    return factorials, invs


# 実装を行う関数
def resolve(test_def_name=""):
    n, k = map(int, input().split())

    # 逆数を求める
    fns, invs = prepare(pow(10, 6))

    # 計算
    ans = 0
    for i in range(1, min(n - 1, k) + 1):
        # (fns[n] * invs[i] * invs[n - i]) 0の部屋パターン数
        # (fns[n - 1] * invs[i] * invs[n - 1 - i])  移動先数(重複組み合わせで求める。)
        ans += (fns[n] * invs[i] * invs[n - i]) * (fns[n - 1] * invs[i] * invs[n - 1 - i]) % (pow(10, 9) + 7)
        ans = ans % (pow(10, 9) + 7)

    # ALL1のパターンを考慮して+1した結果を出力。
    print(ans + 1)


# テストクラス
class TestClass(unittest.TestCase):
    def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

    def test_input_1(self):
        test_input = """3 2"""
        output = """10"""
        self.assertIO(test_input, output)

    def test_input_2(self):
        test_input = """200000 1000000000"""
        output = """607923868"""
        self.assertIO(test_input, output)

    def test_input_3(self):
        test_input = """15 6"""
        output = """22583772"""
        self.assertIO(test_input, output)

    # 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
    def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)


# 実装orテストの呼び出し
if __name__ == "__main__":
    if os.environ.get("USERNAME") is None:
        # AtCoder提出時の場合
        resolve()

    else:
        # 自PCの場合
        unittest.main()
