#include "bits/stdc++.h"
//#include "library.h"

using namespace std;
using ll = long long;

const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;

template<class T>
bool chmax(T &a, const T &b) {
    if (a < b) {
        a = b;
        return 1;
    }
    return 0;
}

template<class T>
bool chmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return 1;
    }
    return 0;
}

//---------------------------------------------------------------------------------------------------
template<int MOD>
struct ModInt {
    static const int Mod = MOD;
    unsigned x;

    ModInt() : x(0) {}

    ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }

    ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }

    int get() const { return (int) x; }

    ModInt &operator+=(ModInt that) {
        if ((x += that.x) >= MOD) x -= MOD;
        return *this;
    }

    ModInt &operator-=(ModInt that) {
        if ((x += MOD - that.x) >= MOD) x -= MOD;
        return *this;
    }

    ModInt &operator*=(ModInt that) {
        x = (unsigned long long) x * that.x % MOD;
        return *this;
    }

    ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }

    ModInt operator+(ModInt that) const { return ModInt(*this) += that; }

    ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }

    ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }

    ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }

    ModInt inverse() const {
        long long a = x, b = MOD, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b;
            std::swap(a, b);
            u -= t * v;
            std::swap(u, v);
        }
        return ModInt(u);
    }

    bool operator==(ModInt that) const { return x == that.x; }

    bool operator!=(ModInt that) const { return x != that.x; }

    ModInt operator-() const {
        ModInt t;
        t.x = x == 0 ? 0 : Mod - x;
        return t;
    }
};

template<int MOD>
std::ostream &operator<<(std::ostream &st, const ModInt<MOD> a) {
    st << a.get();
    return st;
};

template<int MOD>
ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
    ModInt<MOD> r = 1;
    while (k) {
        if (k & 1) r *= a;
        a *= a;
        k >>= 1;
    }
    return r;
}

template<typename T, int FAC_MAX>
struct Comb {
    std::vector<T> fac, ifac;

    Comb() {
        fac.resize(FAC_MAX, 1);
        ifac.resize(FAC_MAX, 1);
        for (int i = 1; i < FAC_MAX; ++i)fac[i] = fac[i - 1] * i;
        ifac[FAC_MAX - 1] = T(1) / fac[FAC_MAX - 1];
        for (int i = FAC_MAX - 2; i >= 1; --i) ifac[i] = ifac[i + 1] * T(i + 1);
    }

    T aPb(int a, int b) {
        if (b < 0 || a < b) return T(0);
        return fac[a] * ifac[a - b];
    }

    T aCb(int a, int b) {
        if (b < 0 || a < b) return T(0);
        return fac[a] * ifac[a - b] * ifac[b];
    }

    T nHk(int n, int k) {
        if (n == 0 && k == 0) return T(1);
        if (n <= 0 || k < 0) return 0;
        return aCb(n + k - 1, k);
    } // nHk = (n+k-1)Ck : n is separator

    T pairCombination(int n) {
        if (n % 2 == 1)return T(0);
        return fac[n] * ifac[n / 2] / (T(2) ^ (n / 2));
    }
    // combination of paris for n
};

typedef ModInt<1000000007> mint;
Comb<mint, 200005> com;

int main() {
    int n, k;
    cin >> n >> k;

    mint ans = 0;
    for (int i = 0; i <= min(k, n - 1); ++i)
        ans += com.aCb(n, i) * com.aCb(n - 1, i);
    cout << ans << endl;
}


Measured memory_bytes: 1792