#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
class llp {
    int v;
    template <class T>
    llp(T a, int) {
        v = a;
    }

public:
    static const int p = 1e9 + 7;

    static const int phi = p - 1;
    llp() { v = 0; }
    template <class T>
    static int mod(T a) {
        return a %= p, a >= 0 ? a : a + p;
    }
    template <class T>
    static T &opmod(T &a) {
        return a = mod(a);
    }
    template <class T>
    llp(T a) {
        v = mod(a);
    }
    template <class T>
    explicit operator T() const {
        return v;
    }
    int operator*() const { return v; }
    int *operator&() const { return (int *)&v; }
    friend istream &operator>>(istream &ipt, llp &x) { return ipt >> x.v, opmod(x.v), ipt; }
    friend ostream &operator<<(ostream &opt, llp x) { return opt << x.v; }
    llp operator+(llp b) const { return v + b.v >= p ? llp(v + b.v - p, 0) : llp(v + b.v, 0); }
    friend llp operator+(ll a, llp b) { return b + a; }
    llp &operator+=(llp b) { return v += b.v, v = v >= p ? v - p : v, *this; }
    llp &operator++() { return *this += 1; }
    llp operator++(int) { return ++*this, *this - 1; }
    llp operator-() const { return v ? llp(p - v, 0) : llp(); }
    llp operator-(llp b) const { return *this + (-b); }
    friend llp operator-(ll a, llp b) { return -b + a; }
    llp &operator-=(llp b) { return *this += -b; }
    llp &operator--() { return *this -= 1; }
    llp operator--(int) { return --*this, *this + 1; }
    llp operator*(llp b) const { return ll(v) * b.v; }
    friend llp operator*(ll a, llp b) { return b * a; }
    llp &operator*=(llp b) { return *this = *this * b; }
    llp operator[](ll b) const {
        llp ans = 1, a = *this;
        while (b) {
            if (b & 1)
                ans *= a;
            a *= a, b >>= 1;
        }
        return ans;
    }
    llp operator^(ll b) const { return (*this)[b]; }
    llp &operator^=(ll b) { return *this = *this ^ b; }
    llp operator~() const { return *this ^ phi - 1; }
    llp operator/(llp b) const { return *this * ~b; }
    friend llp operator/(ll a, llp b) { return (~b) * a; }
    llp &operator/=(llp b) { return *this = *this / b; }
    llp operator<<(int b) const { return *this * llp(2)[b]; }
    llp &operator<<=(int b) { return *this = *this << b; }
    llp operator>>(int b) const { return *this / llp(2)[b]; }
    llp &operator>>=(int b) { return *this = *this >> b; }
    bool operator==(ll b) const { return mod(b) == v; }
    bool operator==(llp b) const { return v == b.v; }
    bool operator!=(ll b) const { return !(*this == b); }
    bool operator!=(llp b) const { return !(*this == b); }
    bool operator<(llp b) const { return v < b.v; }
    bool operator<=(llp b) const { return v <= b.v; }
    bool operator>(llp b) const { return v > b.v; }
    bool operator>=(llp b) const { return v >= b.v; }
    friend llp operator<(ll a, llp b) { return b > a; }
    friend llp operator<=(ll a, llp b) { return b >= a; }
    friend llp operator>(ll a, llp b) { return b < a; }
    friend llp operator>=(ll a, llp b) { return b <= a; }
    int var() const { return v; }
    int mod() const { return p; }
    llp sqd() const { return *this * *this; }
    llp inv() const { return ~*this; }
    llp pow(ll b) const { return *this ^ b; }
};
llp operator""_mod(unsigned long long x) { return llp(x); }
llp operator""_llp(unsigned long long x) { return llp(x); }

int main() {
    int n, a, b;
    cin >> n >> a >> b;
    llp ans = 2;
    ans ^= n;
    llp pa = 1, da = 1;
    for (int i = 0; i < a; ++i) pa *= n - i;
    for (int i = 0; i < a; ++i) da *= i + 1;
    llp pb = 1, db = 1;
    for (int i = 0; i < b; ++i) pb *= n - i;
    for (int i = 0; i < b; ++i) db *= i + 1;
    cout << ans - pa / da - pb / db - 1;
}