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

Examples

Input

3 2


Output

10


Input

200000 1000000000


Output

607923868


Input

15 6


Output

22583772
import java.util.*;

class Main{
    public static final int MOD = 1000000007;

    long[] fac,finv,inv;

    Main(){
        int N, K;
        Scanner SC = new Scanner(System.in);
        N = SC.nextInt();
        K = SC.nextInt();

        init(N+1);

        long R = 0;
        int L;
        if(N-1 <= K)
            L = N-1;
        else{
            L = K;
        }
        
        for(int i=0;i<=L;i++){
            R = (R + COM(N,i) * COM(N-1,N-i-1) % MOD) % MOD;
        }

        System.out.println(R);
    }

    public static void main(String[] args){
        Main main = new Main();
    }


    void init(int max){
        fac  = new long[max];
        finv = new long[max];
        inv  = new long[max];

        fac[0]  = fac[1]  = 1;
        finv[0] = finv[1] = 1;
        inv[1]  = 1;
        for(int i=2; i<max; i++){
            fac[i]  = fac[i-1] * i % MOD;
            inv[i]  = MOD - inv[MOD%i] * (MOD/i) % MOD;
            finv[i] = finv[i-1] * inv[i] % MOD;
        }
    }

    long COM(int n, int k){
        if(n < k)return 0;
        if(n < 0 || k < 0) return 0;
        return fac[n] * (finv[k] * finv[n-k] % MOD) % MOD;
    }
}
