#include <bits/stdc++.h>
#define FOR(i, a, b) for(int i=(a); i<(b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define bit(x) (1L << (x))
using ll = long long;
using namespace std;

template<typename T>
vector<T> make_v(size_t a,T b){return vector<T>(a,b);}
 
template<typename... Ts>
auto make_v(size_t a,Ts... ts){
        return vector<decltype(make_v(ts...))>(a,make_v(ts...));
}

constexpr int default_mod = 1e9 + 7;
constexpr bool default_isPrime = true;

template<int Mod = default_mod, bool IsPrime = default_isPrime>
class mint {
        ll n_;
public:
        constexpr mint(ll n): n_{n} { 
                if (n >= Mod) {
                        n_ %= Mod;
                } else {
                        n_ = (n_ % Mod + Mod) % Mod;
                }
        }

        constexpr mint() : n_{0} {}

        constexpr operator int() const { return n_; }
        constexpr operator ll() const { return n_; }

        constexpr mint& operator==(const mint& n) {
                return n_ == n.n_;
        }

        constexpr mint& operator=(const mint& n) {
                n_ = n.n_;
                return *this;
        }

        constexpr mint& operator+=(const mint& n) {
                if ((n_ += n.n_) >= Mod) n_ -= Mod;
                return *this;
        }

        constexpr mint& operator-=(const mint& n) {
                if ((n_ -= n.n_) < 0) n_ += Mod;
                return *this;
        }
        
        constexpr mint& operator*=(const mint& n) {
                if ((n_ *= n.n_) >= Mod) n_ %= Mod;
                return *this;
        }

        constexpr mint& operator/=(const mint& n) {
                return *this *= n.inverse();
        }

        constexpr typename enable_if<IsPrime, mint>::type inverse() const {
                ll a = n_, b = Mod, u = 1, v = 0;
                while (b) {
                        ll t = a / b;
                        a -= t * b; swap(a, b);
                        u -= t * v; swap(u, v);
                }
                return mint(u);
        }

        constexpr mint operator+(mint n) const { return mint(*this) += n; }
        constexpr mint operator-(mint n) const { return mint(*this) -= n; }
        constexpr mint operator*(mint n) const { return mint(*this) *= n; }
        constexpr mint operator/(mint n) const { return mint(*this) /= n; }

};

template<int Mod = default_mod, bool IsPrime = default_isPrime>
ostream& operator<<(ostream& os, mint<Mod, IsPrime> const& n) {
        os << (int)n;
        return os;
}

template<int Mod = default_mod, bool IsPrime = default_isPrime>
mint<Mod, IsPrime> fact(int n) {
        static vector<mint<Mod, IsPrime>> v {1};

        if (n >= static_cast<int>(v.size())) {
                const int from = v.size(), to = n + 1024;
                v.reserve(to);
                for (int i = from; i < to; i++) {
                        v.push_back(v.back() * mint<Mod, IsPrime>(i));
                }
        }
        
        return v[n];
}

template<int Mod = default_mod, bool IsPrime = default_isPrime>
mint<Mod, IsPrime> comb(int n, int r) {
        if (r < 0 || n < r) {
                return 0;
        } else {
                return fact<Mod, IsPrime>(n) / fact<Mod, IsPrime>(r) / fact<Mod, IsPrime>(n - r);
        }
}

template<int Mod = default_mod, bool IsPrime = default_isPrime>
mint<Mod, IsPrime> comb2(int n, int r) {
        mint<Mod, IsPrime> ret(1);

        for (int i = 0; i < r; i++) {
                ret *= mint<Mod, IsPrime>(n - i) / mint<Mod, IsPrime>(r - i);
        }

        return ret;
}

template<typename T>
T pow(T x, int n) {
        if (n == 0) {
                return T(1);
        } else {
                T rest = (n % 2) ? x : T(1);
                return pow(x * x, n / 2) * rest;
        }
}

using mi = mint<>;

int main() {
        ll n, a, b;
        cin >> n >> a >> b;
        
        mi ans = pow(mi(2), n) - comb2(n, 0) - comb2(n, a) - comb2(n, b);

        cout << ans << endl;

        return 0;
}


Measured memory_bytes: 256