//#include <bits/stdc++.h>
#include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> VI;
typedef vector<VI> VVI;//例: VVI dp(10, vector<int>(10, INF);
typedef priority_queue<int, vector<int>, less<int> > QUE_int;
const int INF = 2 * pow(10, 9) + 1;//+1しないとREになるかも(out of rangeになるんかな?? )

vector<int> dx = { -1, 0, 1, 0, -1, -1, 1, 1 };
vector<int> dy = { 0, -1, 0, 1, -1, 1, -1, 1 };

ll max(ll a, ll b) { return (a > b) ? a : b; }
ll min(ll a, ll b) { return (a < b) ? a : b; }

////////////////////////////////////////////////////////////////
const ll MOD = pow(10, 9) + 7;
// a+b mod MOD
ll add_mod(ll a, ll b) {return (a % MOD + b % MOD) % MOD;}


// a-b mod MOD
ll sub_mod(ll a, ll b) {
	ll res = add_mod(a, -b);
	if (res < 0) return  res + MOD;
	return res;
}

// a*b mod MOD
ll mul_mod(ll a, ll b) {return ((a % MOD) * (b % MOD)) % MOD;}

// a^n mod MOD
ll pow_mod(ll a, ll n) {
	
	ll res = 1;
	while (n > 0) {
		if (n & 1) res = mul_mod(res, a);
		a = mul_mod(a, a);
		n >>= 1;
	}
	return res;
}

//  a/b mod MOD
ll div_mod(ll a, ll b) { return  a * (pow_mod(b, MOD - 2)); }// a/b(mod MOD)   =  a * b^(MOD-2)   (mod MOD)

// nCr mod MOD
ll comb_mod(ll n, ll r) {
	ll res = 1;
	for (int i = 0; i < r; i++) {//nCrの計算 =   {n (n-1) (n-2)  ... (n-r+1) }   /   { r (r-1) (r-2) ... (r-r+1)}
		res = mul_mod(res, n - i);
		res = div_mod(res, r - i);
	}
	return res;
}

// nPr mod MOD
ll perm_mod(ll n, ll r) {
	ll res = 1;
	for (int i = 0; i < r; i++) res = mul_mod(res, n - i);// n(n-1)(n-2)...(n-r+1)
	return res;
}

// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
  ll x; // typedef long long ll;
  mint(ll x=0):x((x%mod+mod)%mod){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
  mint pow(ll t) const {
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }

  // for prime mod
  mint inv() const {
    return pow(mod-2);
  }
  mint& operator/=(const mint a) {
    return (*this) *= a.inv();
  }
  mint operator/(const mint a) const {
    mint res(*this);
    return res/=a;
  }
};


// combination mod prime
// https://www.youtube.com/watch?v=8uowVvQ_-Mo&feature=youtu.be&t=1619
struct combination {
  vector<mint> fact, ifact;
  combination(int n):fact(n+1),ifact(n+1) {
    assert(n < mod);
    fact[0] = 1;
    for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;
    ifact[n] = fact[n].inv();
    for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;
  }
  mint operator()(int n, int k) {
    if (k < 0 || k > n) return 0;
    return fact[n]*ifact[k]*ifact[n-k];
  }
};
////////////////////////////////////////////////////////////////

int main(void) {
  int n, k;
  cin >> n >> k;
  
  if(k >= n) k = n-1; //kはn以上であっても関係ない
  
  combination c(n);
  
  mint ans;
  for(int i=0; i<=k; i++){
    //ll zero = comb_mod(n, i);//i個の0の場所の選び方
    //ll non_zero = comb_mod(n-i+i-1, i);//n-i種類の品物を計i個選ぶ選び方(重複組み合わせ)
    //ll zero = c(n, i);
    //ll non_zero = c(n-i+i-1, i);
    
    ans = ans +  c(n, i)*c(n-i+i-1, i);
    //cout << " ans: " << ans << " zero: " << zero << " non_zero: " << non_zero << endl;
  }
  
  cout << ans.x  << endl;

}


Measured memory_bytes: 3328