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 C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
 
using namespace std;

#define M 1000000007
#define pb emplace_back
#define f first
#define s second
#define rep(i, st, ed) for(ll i=st; i<ed; ++i)
#define repn(i, st, ed) for(ll i=st; i<=ed; ++i)
#define repb(i, ed, st) for(ll i=ed; i>=st; --i)
#define all(v) v.begin(),v.end()
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
#define PI acosl(-1.0)
#define mp(a, b) make_pair(a, b)
#define eps 1e-9

typedef long long ll;
typedef unsigned long long int llt;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vec;
typedef vector<pll> vecp;
typedef map<ll, ll> mpll;


const int N = 1e5 + 10;
const ll INF = 1LL << 60;
#define MOD 1000000007
template<int mod>
struct ModInt{
  int x;
  ModInt():x(0){}
  ModInt(long long y):x(y>=0?y%mod:(mod-(-y)%mod)%mod){}
  ModInt &operator+=(const ModInt &p){
    if((x+=p.x)>=mod)x-=mod;
    return *this;
  }
  ModInt &operator-=(const ModInt &p){
    if((x+=mod-p.x)>=mod)x-=mod;
    return *this;
  }
  ModInt &operator*=(const ModInt &p){
    x=(int)(1LL*x*p.x%mod);
    return *this;
  }
  ModInt &operator/=(const ModInt &p){
    *this*=p.inverse();
    return *this;
  }
  ModInt &operator^=(long long p){
    ModInt res = 1;
    for (; p; p >>= 1) {
      if (p & 1) res *= *this;
      *this *= *this;
    }
    return *this = res;
  }
  ModInt operator-()const{return ModInt(-x);}
  ModInt operator+(const ModInt &p)const{return ModInt(*this)+=p;}
  ModInt operator-(const ModInt &p)const{return ModInt(*this)-=p;}
  ModInt operator*(const ModInt &p)const{return ModInt(*this)*=p;}
  ModInt operator/(const ModInt &p)const{return ModInt(*this)/=p;}
  ModInt operator^(long long p)const{return ModInt(*this)^=p;}
  bool operator==(const ModInt &p)const{return x==p.x;}
  bool operator!=(const ModInt &p)const{return x!=p.x;}
  explicit operator int() const { return x; }              // added by QCFium
  ModInt operator=(const int p) {x = p; return ModInt(*this);} // added by QCFium
  ModInt inverse()const{
    int a=x,b=mod,u=1,v=0,t;
    while(b>0){
      t=a/b;
      a-=t*b;
      std::swap(a,b);
      u-=t*v;
      std::swap(u,v);
    }
    return ModInt(u);
  }
  friend std::ostream &operator<<(std::ostream &os,const ModInt<mod> &p){
    return os<<p.x;
  }
  friend std::istream &operator>>(std::istream &is,ModInt<mod> &a){
    long long x;
    is>>x;
    a=ModInt<mod>(x);
    return (is);
  }
};
typedef ModInt<MOD> mint;
 
struct MComb {
  std::vector<mint> fact;
  std::vector<mint> inversed;
  MComb(int n) { // O(n+log(mod))
    fact = std::vector<mint>(n+1,1);
    for (int i = 1; i <= n; i++) fact[i] = fact[i-1]*mint(i);
    inversed = std::vector<mint>(n+1);
    inversed[n] = fact[n] ^ (MOD-2);
    for (int i = n - 1; i >= 0; i--) inversed[i]=inversed[i+1]*mint(i+1);
  }
  mint ncr(int n, int r) {
    return (fact[n] * inversed[r] * inversed[n-r]);
  }
  mint npr(int n, int r) {
    return (fact[n] * inversed[n-r]);
  }
  mint nhr(int n, int r) {
    assert(n+r-1 < (int)fact.size());
    return ncr(n+r-1, r);
  }
};

void solve()
{
    
    int n, k;
    cin>>n>>k;
    MComb comb(2*n + 1);
    mint ans = 0;
    for(int i=0; i < n; i++){
      if(i > k) break;
      int m = n - i;
      ans += comb.ncr(n, i) * comb.ncr(m-1+i, i);
    }
    cout<<ans<<endl;
}


int main()
{
    ll Tests = 1;
    //cin>>Tests;
    while(Tests--)
    {
        solve();
    }
    return 0;
}