#include<bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for(int (i) = 0; (i) < (N); (i)++)
#define all(v) (v).begin(), (v).end()
#define eb emplace_back

#include<iostream>
#include<cstdint>

using i64 = int_fast64_t;
struct mint{
    using i64 = int_fast64_t;
    i64 x;
    const i64 MOD = 1000000007;

    mint(const i64 y = (i64)0) noexcept : x(y) { if(x >= MOD) x %= MOD; }
    mint operator+() const noexcept {return x;}

    mint operator+(const mint y) const noexcept {return (mint)*this += y; }
    mint operator-(const mint y) const noexcept {return (mint)*this -= y; }
    mint operator*(const mint y) const noexcept {return (mint)*this *= y;}
    mint operator/(const mint y) const noexcept {return (mint)*this /= y;}

    mint operator=(const mint y) noexcept {
        x = y.x;
        if(x >= MOD) x -= MOD;
        if(x < 0) x += MOD;
        return *this;
    }
    mint operator=(const i64 y) noexcept {
        x = y;
        return *this;
    }
    mint& operator+=(const mint y) noexcept {
        x += y.x; 
        if(x >= MOD) x -= MOD;
        return *this;
    }
    mint& operator-=(const mint y) noexcept {
        x -= y.x;
        if(x < 0) x += MOD;
        return *this;
    }
    mint& operator*=(const mint y) noexcept {
        x *= y.x;
        if(x >= MOD) x %= MOD;
        return *this;
    }
    mint& operator/=(mint y) noexcept {
        i64 exp = MOD - 2;
        while(exp){
            if(exp & 1) *this *= y;
            y *= y;
            exp /= 2;
        }
        return *this;
    }
    friend std::ostream& operator<< (std::ostream& os, const mint& m);
    friend std::istream& operator>> (std::istream& in, mint& m);
};
std::ostream& operator<<(std::ostream& os, const mint& m){
    os << m.x;
    return os;
}
std::istream& operator>> (std::istream& in, mint& m){
    const int MOD = 1000000007;
    in >> m.x; 
    if(m.x < 0) m.x += MOD;
    if(m.x >= MOD) m.x %= MOD;
    return in; 
}

class Binomial {
private:
    #define MOD 1000000007
    vector<mint> fac;
    vector<mint> finv;
    vector<mint> inv;
    size_t sz;

    mint for_big_N(const int& n, const int& r) const {
        mint res = 1;
        const int k = min(r, n-r);
        for(int i = 0; i < k; i++){
            res *= mint(n - i) / mint(k - i);
        }
        return res;
    }
public:
    Binomial operator=(const Binomial) = delete;
    Binomial (const Binomial&) = delete;
    Binomial(size_t s = 510000): sz(s) {
        fac.resize(sz), inv.resize(sz), finv.resize(sz);
        fac[0] = fac[1] = 1;
        inv[1] = 1;
        finv[0] = finv[1] = 1;
        for(int i = 2; i < sz; i++){
            fac[i] = fac[i-1] * mint(i);
            inv[i] = mint(MOD) - inv[MOD % i] * mint(MOD / i);
            finv[i] = finv[i-1] * inv[i];
        }
    }
    mint operator() (const int& n, const int& r) const {
        if(n < r) return mint(0);
        if(n < 0 || r < 0) return mint(0);
        if(n >= sz) return for_big_N(n, r);

        return fac[n] * finv[n-r] * finv[r];
    }
};

mint POW(mint n, i64 k){
    mint res = 1;
    while(k){
        if(k&1) res *= n;
        n *= n;
        k >>= 1;
    }
    return res;
}

int main(){
    int N, A, B;
    cin >> N >> A >> B;
    Binomial binomial;
    cout << POW(2, N) - 1 - binomial(N, A) - binomial(N, B) << endl;
}

Measured memory_bytes: 24320