#include <bits/stdc++.h>
using namespace std;
#define M 1000000007
#define pb emplace_back
#define f first
#define s second
#define rep(i, st, ed) for(ll i=st; i<ed; ++i)
#define repn(i, st, ed) for(ll i=st; i<=ed; ++i)
#define repb(i, ed, st) for(ll i=ed; i>=st; --i)
#define all(v) v.begin(),v.end()
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
#define PI acosl(-1.0)
#define mp(a, b) make_pair(a, b)
#define eps 1e-9
#define FAST ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef long long ll;
template<class T> void chmax(T &a,T b) { if (a<b) a=b;}
template<class T> void chmin(T &a,T b) { if (a>b) a=b;}
const int N = 2e5 + 10;
const ll INF = 1LL << 60;
#define MOD 1000000007
template<int mod>
struct ModInt{
  int x;
  ModInt():x(0){}
  ModInt(long long y):x(y>=0?y%mod:(mod-(-y)%mod)%mod){}
  ModInt &operator+=(const ModInt &p){
    if((x+=p.x)>=mod)x-=mod;
    return *this;
  }
  ModInt &operator-=(const ModInt &p){
    if((x+=mod-p.x)>=mod)x-=mod;
    return *this;
  }
  ModInt &operator*=(const ModInt &p){
    x=(int)(1LL*x*p.x%mod);
    return *this;
  }
  ModInt &operator/=(const ModInt &p){
    *this*=p.inverse();
    return *this;
  }
  ModInt &operator^=(long long p){
    ModInt res = 1;
    for (; p; p >>= 1) {
      if (p & 1) res *= *this;
      *this *= *this;
    }
    return *this = res;
  }
  ModInt operator-()const{return ModInt(-x);}
  ModInt operator+(const ModInt &p)const{return ModInt(*this)+=p;}
  ModInt operator-(const ModInt &p)const{return ModInt(*this)-=p;}
  ModInt operator*(const ModInt &p)const{return ModInt(*this)*=p;}
  ModInt operator/(const ModInt &p)const{return ModInt(*this)/=p;}
  ModInt operator^(long long p)const{return ModInt(*this)^=p;}
  bool operator==(const ModInt &p)const{return x==p.x;}
  bool operator!=(const ModInt &p)const{return x!=p.x;}
  explicit operator int() const { return x; }              // added by QCFium
  ModInt operator=(const int p) {x = p; return ModInt(*this);} // added by QCFium
  ModInt inverse()const{
    int a=x,b=mod,u=1,v=0,t;
    while(b>0){
      t=a/b;
      a-=t*b;
      std::swap(a,b);
      u-=t*v;
      std::swap(u,v);
    }
    return ModInt(u);
  }
  friend std::ostream &operator<<(std::ostream &os,const ModInt<mod> &p){
    return os<<p.x;
  }
  friend std::istream &operator>>(std::istream &is,ModInt<mod> &a){
    long long x;
    is>>x;
    a=ModInt<mod>(x);
    return (is);
  }
};
typedef ModInt<MOD> mint;
 
struct MComb {
  std::vector<mint> fact;
  std::vector<mint> inversed;
  MComb(int n) { // O(n+log(mod))
    fact = std::vector<mint>(n+1,1);
    for (int i = 1; i <= n; i++) fact[i] = fact[i-1]*mint(i);
    inversed = std::vector<mint>(n+1);
    inversed[n] = fact[n] ^ (MOD-2);
    for (int i = n - 1; i >= 0; i--) inversed[i]=inversed[i+1]*mint(i+1);
  }
  mint ncr(int n, int r) {
    return (fact[n] * inversed[r] * inversed[n-r]);
  }
  mint npr(int n, int r) {
    return (fact[n] * inversed[n-r]);
  }
  mint nhr(int n, int r) {
    assert(n+r-1 < (int)fact.size());
    return ncr(n+r-1, r);
  }
  mint ncrbig(int n, int r){
    mint ans = 1;
    int x = min(n-r,r);
    int y = max(n-r,r);
    for(int i=n;i>y;--i) ans*=mint(i);
    for(int i=1;i<=x;++i) ans*= mint(i)^(MOD-2);
    return ans;
  }
};

// How to use mint

/*
int main() {
  MComb com(2 * n + 1);
  mint res = 0;
  for (int i = 0; i < n; i++) {
    if (i > k) break;
    int m = n - i;
    res += com.ncr(n, i) * com.ncr(m - 1 + i, i);
  }
  std::cout << res << std::endl;
  return 0;
}
*/


// one more technique to calculate nCr
/*
ll iv[N];
ll powM(ll a, ll b){ll res = 1;for(;b;a=a*a%M,b/=2) if(b&1) res=res*a%M;return res;}
ll nckbig(int n, int k){ll ans = 1;for(int i=1; i<=k; ++i){ans = ans*(n-i+1)%M*iv[i]%M;}return ans;}
ll caliv(){iv[1] = 1;for(int i=2; i<N; i++){iv[i] = M-M/i*iv[M%i]%M;}}
ll f1[N], f2[N];
ll calf(){f1[0] = f2[0] = 1;for(int i=2; i <N; ++i){f1[i] = f1[i-1]*i%M;f2[i] = f2[i-i]*iv[i]%M;}}
ll nck(int n, int k){return f1[n]*f2[n-k]%M*f2[k]%M;}
ll npk(int n, int k){return f1[n]*f2[n-k]%M;}
ll Rnck(int big){if(big){caliv();}else{calf();}}
*/

void solve()
{
  ll n, a, b;
  cin>>n>>a>>b;
  mint ans = (mint(2)^n) - mint(1);
  MComb comb(0);
  cout<<(ans - comb.ncrbig(n, a) - comb.ncrbig(n, b))<<endl;
}


int main()
{
    FAST
    ll Tests = 1;
    //cin>>Tests;
    while(Tests--)
    {
        solve();
    }
    return 0;
}

Measured memory_bytes: 256