#include <bits/stdc++.h>
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define tr(c, i) for (iter(c) i = (c).begin(); i != (c).end(); ++i)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
using namespace std;

typedef long long ll;

// {{{ ModInt
template<int _MOD>
struct ModInt {
   static const auto MOD = _MOD;
   template<class T> using integral_only = typename enable_if<is_integral<T>::value>::type;
    int x;   
   constexpr ModInt() : x() {}
   template<class T, integral_only<T>* = nullptr>
    ModInt(T _x=0) {
      x = _x % MOD;
      if(x<0) x+=MOD;
   }
    ModInt operator-() const { return {x == 0? 0 : MOD-x}; }
    ModInt& operator+=(const ModInt a) {
        if ((x += a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator-=(const ModInt a) {
        if ((x += MOD-a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator*=(const ModInt a) {
        x = (long long)x * a.x % MOD;
        return *this;
    }
    ModInt& operator/=(const ModInt a) {
        return (*this) *= a.inv();
    }
    ModInt operator+(const ModInt a) const { return ModInt(*this) += a; }
    ModInt operator-(const ModInt a) const { return ModInt(*this) -= a; }
    ModInt operator*(const ModInt a) const { return ModInt(*this) *= a; }
    ModInt operator/(const ModInt a) const { return ModInt(*this) /= a; }
    ModInt inv() const {
       // for prime MOD
        return pow(MOD-2);
    }
   ModInt inv2() const {
      // work for non-prime MOD if gcd(x,MOD) = 1
      int a = x, b = MOD, u = 1, v = 0;
      while(b != 0) {
         int t = a / b;
         a -= t * b;
         u -= t * v;
         swap(a, b);
         swap(u, v);
      }
      return u;
   }
   template<class T, integral_only<T>* = nullptr>
    ModInt pow(T t) const {
      ModInt r = 1, p = *this;
      while(t) {
         if(t & 1) r *= p;
         p *= p;
         t >>= 1;
      }
        return r;
    }
    bool operator==(ModInt rhs) const { return x == rhs.x; }
    bool operator!=(ModInt rhs) const { return x != rhs.x; }
    bool operator<(ModInt rhs) const { return x < rhs.x; }
    bool operator<=(ModInt rhs) const { return x <= rhs.x; }
    bool operator>(ModInt rhs) const { return x > rhs.x; }
    bool operator>=(ModInt rhs) const { return x >= rhs.x; }
    friend string to_string(ModInt i) { return to_string(i.x); }
    friend istream& operator>>(istream&i,ModInt&a) { return i>>a.x; }
    friend ostream& operator<<(ostream&o,const ModInt&a) { return o<<a.x; }
};
const int MOD=1000000007;
using mint=ModInt<MOD>;
// }}}

struct Comb {
  vector<mint> fact, ifact;
  Comb(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];
  }
};

const int N=2e5+5;
Comb C(N*2);
int main() {
   int n, k;
   cin >> n >> k;
   mint ans=0;
   k=min(n-1,k); // 最多幾個0
   for (int i=0; i<=k; i++) { // 有幾個0
      ans+=C(n,i)*C(n-i+i-1, i);
   }
   cout << ans << '\n';
   return 0;
}


Measured memory_bytes: 3328