#include <iostream>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#define rep(i,n) for(int i = 0; i < (n); ++i)
#define MOOD 1000000007

using namespace std;
using ll = long long;
using P = pair<int,int>;

struct UnionFind{
    vector<int> d;
    UnionFind(int n = 0):d(n,-1){};

    int find(int x){
        if(d[x] < 0) {
            return x;
        }
        else{
            return d[x] = find(d[x]);
        }
    }
    bool unite(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) return false;
        if (d[x] > d[y]) swap(x, y);

        d[x] += d[y];
        d[y] = x;
        return true;
    }
    bool same(int x, int y){
        return find(x) == find(y);
    }
    int size(int x){
        return -d[find(x)];
    }

};

struct mint {
    ll x;

    mint(ll x) : x((x % MOOD + MOOD) % MOOD) {}

    mint operator-() const { return mint(-x); }

    mint &operator+=(const mint a) {
        if ((x += a.x) >= MOOD) x -= MOOD;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += MOOD-a.x) >= MOOD) x -= MOOD;
        return *this;
    }

    mint &operator*=(const mint a) {
        if ((x *= a.x) %= MOOD);
        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(ll t) const{
        if(!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if(t&1) a *= *this;
        return a;
    }

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

    mint& operator/=(const mint a) {
        return (*this) *= a.inv();
    }

    mint operator/(const mint a) const {
        mint res(*this);
        return res/=a;
    }

};

mint kaijyo(int n) {
    if (n == 0) return 1;
    mint x = kaijyo(n/2);
    x *= x;
    if (n%2 == 1) x *= 2;
    return x;
}

mint choose(int n, int a) {
    mint x = 1, y = 1;
    rep(i,a) {
        x *= n-i;
        y *= i+1;
    }
    return x / y;
}





int main() {
    ll n;
    ll a;
    ll b;
    scanf("%lld %lld %lld",&n,&a,&b);

    mint ans = kaijyo(n);
    ans = ans - 1;
    ans = ans - choose(n,a);
    ans = ans - choose(n,b);
    printf("%lld",ans);

}

int A(){
    int N,K;
    scanf("%d %d",&N,&K);
    if(N < 10){
        printf("%d",K+100*(10-N));
    }
    else{
        printf("%d",K);
    }
    return 0;
}

int B(){
    long long int N,K;
    scanf("%lld %lld",&N,&K);
    long long int count = 0;
    long long int digit = 1;
    while(1){
        digit = digit*K;
        count++;
        if(N == digit ){
            printf("%lld",count+1);
            return 0;
        }
        else if(N/digit == 0){
            printf("%lld",count);
            return 0;
        }
    }
}

int C(){
    int N;
    scanf("%d",&N);

    int X[N];
    rep(i,N)scanf("%d",&X[i]);
    int ans = 1000000;
    int souwa[100];
    rep(i,100){
        souwa[i] = 0;
        rep(j,N){
            souwa[i] += ((i+1)-X[j])*((i+1)-X[j]);
        }
        if(ans > souwa[i]){
            ans = souwa[i];
        }
    }
    printf("%d",ans);
    return 0;
}


Measured memory_bytes: 256