// Original C++ solution (slower):
#include <iostream>

#include <iomanip>

#include <vector>

#include <utility>

#include <map>

#include <algorithm>

#include <queue>

#include <cmath>

#include <numeric>

#include <set>



using namespace std;

struct aaa{aaa(){cin.tie(nullptr); ios::sync_with_stdio(false); cout<<fixed<<setprecision(20);};}aaa;

template <class T>ostream &operator<<(ostream &o,const vector<T>&v){o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}

#define debug(v) {cerr<<"\033[1;36m[debug]\033[m "<<#v<<" : "<<v<<endl;}



using int64 = long long;



void solve1(int64, int64, int64);



const int mod = 1000000007;

struct mint {

    int64 x; // typedef long long int64;

    mint(int64 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(int64 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;

    }

};



mint nCr(int64 n, int64 r) {

    if (n < r) return 0;

    mint x = 1;

    mint y = 1;

    for (int i=1; i<=r; i++) {

        x *= (n - i + 1);

        y *= i;

    }

    return x / y;

}





const int N = 1000000;

int main() {

    int64 n,a,b;

    cin >> n >> a >> b;



    mint ans = mint(2).pow(n);

    ans -= 1;

    ans -= nCr(n,a);

    ans -= nCr(n,b);







    cout << ans.x << endl;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <iomanip>

#include <vector>

#include <utility>

#include <map>

#include <algorithm>

#include <queue>

#include <cmath>

#include <numeric>

#include <set>



using namespace std;

struct aaa{aaa(){cin.tie(nullptr); ios::sync_with_stdio(false); cout<<fixed<<setprecision(20);};}aaa;

template <class T>ostream &operator<<(ostream &o,const vector<T>&v){o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}

#define debug(v) {cerr<<"\033[1;36m[debug]\033[m "<<#v<<" : "<<v<<endl;}



using int64 = long long;



void solve1(int64, int64, int64);



const int MOD = 1000000007;

struct mint {

    int64 x;

    mint(const int64 x1=0) { x = x1%MOD; };



    mint& operator++(int n) { x+=1; return *this; };

    mint& operator--(int n) { x-=1; return *this; };

    mint& operator=(int64 n) { x=n%MOD; return *this; };

    mint& operator--() {x-=1; return *this; };

    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) { return (*this) *= a.inv();}

    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 operator/(const mint a) const { mint res(*this); return res/=a; }

    mint inv() const { return pow(MOD-2);}

    friend ostream& operator<<(ostream &os, const mint a) noexcept { return os << a.x; }

    constexpr bool operator == (const mint& r) const noexcept { return this->x == r.x; }

    constexpr bool operator != (const mint& r) const noexcept { return this->x != r.x; }

    mint pow(long long t) const {

        if (!t) return mint(1);

        mint a = pow(t>>1);

        a*=a;

        if(t&1) a*= *this;

        return a;

    }

};



mint nCr(int64 n, int64 r) {

    if (n < r) return 0;

    mint x = 1;

    mint y = 1;

    for (int i=1; i<=r; i++) {

        x *= (n - i + 1);

        y *= i;

    }

    return x / y;

}





const int N = 1000000;

int main() {

    int64 n,a,b;

    cin >> n >> a >> b;



    mint ans = mint(2).pow(n) - 1;

    ans -= nCr(n,a);

    ans -= nCr(n,b);

    debug(ans);





    cout << ans << endl;

}

// Fastest known solution for this problem: