Problem:
Score : 500 points

Problem 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).

Constraints

All values in input are integers.

3 \leq n \leq 2 \times 10^5

2 \leq k \leq 10^9

Input

Input is given from Standard Input in the following format:

n k

Output

Print the number of possible combinations of numbers of people in the n rooms now, modulo (10^9 + 7).

Sample Input 1

3 2

Sample Output 1

10

Let c_1, c_2, and c_3 be the number of people in Room 1, 2, and 3 now, respectively. There are 10 possible combination of (c_1, c_2, c_3):

(0, 0, 3)

(0, 1, 2)

(0, 2, 1)

(0, 3, 0)

(1, 0, 2)

(1, 1, 1)

(1, 2, 0)

(2, 0, 1)

(2, 1, 0)

(3, 0, 0)

For example, (c_1, c_2, c_3) will be (0, 1, 2) if the person in Room 1 goes to Room 2 and then one of the persons in Room 2 goes to Room 3.

Sample Input 2

200000 1000000000

Sample Output 2

607923868

Print the count modulo (10^9 + 7).

Sample Input 3

15 6

Sample Output 3

22583772

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.util.Scanner;

public class Main {
	static int MOD = 1000000007;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		int NINV = modInv(n, MOD);

		long combi = 1;
		long ans = 1;
		for ( int i = 0 ; i < Math.min(n - 1, k) ; i++ ) {
			combi = (combi * (n - i)) % MOD;
			combi = (combi * (modInv(i + 1, MOD))) % MOD;

			long h = (combi * (n - i - 1)) % MOD;
			h = (h * NINV) % MOD;

			long p = (combi * h) % MOD;
			ans = (ans + p) % MOD;
		}

		System.out.println(ans);
	}

	static int power(int base, int exp, int mod) {
		long res = 1;
		int first = base % mod;
		int cnt = exp == 0 ? 0 : firstBitPos(exp) + 1;
		while ( cnt >= 0 ) {
			res = (res * res) % mod;
			if ( ((exp >> cnt) & 1) != 0 ) {
				res = (res * first) % mod;
			}
			cnt--;
		}
		return (int) res;
	}

	// 最大公約数と、ax + by = gcdを満たすx,yを計算する
	static int[] xgcd(int a, int b) {
		int x0 = 1;
		int y0 = 0;
		int x1 = 0;
		int y1 = 1;
		while ( b != 0 ) {
			int q = a / b;
			int tmp = b;
			b = a % b;
			a = tmp;

			tmp = x1;
			x1 = x0 - q * x1;
			x0 = tmp;

			tmp = y1;
			y1 = y0 - q * y1;
			y0 = tmp;
		}
		return new int[] {a, x0, y0};
	}

	// 逆元
	static int modInv(int a, int mod) {
		int[] xgcd = xgcd(a, mod);
		return (xgcd[1] + mod) % mod;
	}

	static int firstBitPos(int num) {
		int x = num | (num >> 1);
		x |= x >> 2;
		x |= x >> 4;
		x |= x >> 8;
		x |= x >> 16;
		return countBits(x);
	}

	static int countBits(int num) {
		int cnt = (num & 0x55555555) + (num >> 1 & 0x55555555);
		cnt = (cnt & 0x33333333) + (cnt >> 2 & 0x33333333);
		cnt = (cnt & 0x0f0f0f0f) + (cnt >> 4 & 0x0f0f0f0f);
		cnt = (cnt & 0x00ff00ff) + (cnt >> 8 & 0x00ff00ff);
		return (cnt & 0x0000ffff) + (cnt >> 16 & 0x0000ffff);
	}
}