#include <iostream>

using i64 = int_fast64_t;
using u64 = uint_fast64_t;
using i32 = int_fast32_t;
using u32 = uint_fast32_t;

template<typename T, T Mod>
class Modint {
private:
	T value;

public:
	Modint() noexcept: value(0) {
	}

	Modint(const T &x) noexcept: value(x % Mod) {
	}

	Modint(T &&x) noexcept: value(x % Mod) {
	}

	Modint pow(u64 n) const noexcept {
		Modint res = 1;
		Modint a(*this);
		while(n) {
			if(n & 1) res *= a;
			a *= a;
			n >>= 1;
		}
		return res;
	}

	Modint inv() const noexcept {
		return pow(Mod - 2);
	}

	/* operators */
	// io
	friend std::ostream &operator <<(std::ostream &os, const Modint &x) noexcept {
		os << x.value;
		return os;
	}

	friend std::istream &operator >>(std::istream &is, Modint &x) noexcept {
		is >> x.value;
		return is;
	}

	// arithmetic
	Modint &operator +=(const Modint &rhs) noexcept {
		this->value += rhs.value;
		if(this->value >= Mod) this->value -= Mod;
		return *this;
	}

	Modint &operator -=(const Modint &rhs) noexcept {
		if(this->value < rhs.value) this->value += Mod;
		this->value -= rhs.value;
		return *this;
	}
	
	Modint &operator *=(const Modint &rhs) noexcept {
		this->value = this->value * rhs.value % Mod;
		return *this;
	}

	Modint &operator /=(const Modint &rhs) noexcept {
		this->value = this->value * rhs.pow(Mod - 2).value % Mod;
		return *this;
	}

	Modint &operator %=(const Modint &rhs) noexcept {
		this->value %= rhs.value;
		return *this;
	}

	Modint operator +(const Modint &rhs) const noexcept {
		return Modint(*this) += rhs;
	}

	Modint operator -(const Modint &rhs) const noexcept {
		return Modint(*this) -= rhs;
	}

	Modint operator *(const Modint &rhs) const noexcept {
		return Modint(*this) *= rhs;
	}

	Modint operator /(const Modint &rhs) const noexcept {
		return Modint(*this) /= rhs;
	}

	Modint operator %(const Modint &rhs) const noexcept {
		return Modint(*this) %= rhs;
	}

	// unary
	Modint &operator ++() noexcept {
		operator +=(1);
		return *this;
	}

	Modint &operator ++(int) noexcept {
		Modint x = *this;
		operator -=(1);
		return x;
	}

	Modint &operator --() noexcept {
		operator -=(1);
		return *this;
	}

	Modint &operator --(int) noexcept {
		Modint x = *this;
		operator -=(1);
		return x;
	}

	Modint operator +() noexcept {
		return *this;
	}

	Modint operator -() noexcept {
		if(this->value != 0) this->value = Mod - this->value;
		return *this;
	}

	// comparison
	friend bool operator ==(const Modint &lhs, const Modint &rhs) noexcept {
		return lhs.value == rhs.value;
	}

	friend bool operator !=(const Modint &lhs, const Modint &rhs) noexcept {
		return lhs.value != rhs.value;
	}

	friend bool operator <(const Modint &lhs, const Modint &rhs) noexcept {
		return lhs.value < rhs.value;
	}

	friend bool operator <=(const Modint &lhs, const Modint &rhs) noexcept {
		return lhs.value <= rhs.value;
	}

	friend bool operator >(const Modint &lhs, const Modint &rhs) noexcept {
		return lhs.value > rhs.value;
	}

	friend bool operator >=(const Modint &lhs, const Modint &rhs) noexcept {
		return lhs.value >= rhs.value;
	}

	inline T val() const noexcept {
		return this->value;
	}
};

template<typename T, T Mod>
Modint<T, Mod> nCr(T n, T r) { 
	Modint<T, Mod> ret(1);

	while(r != 0) {
		Modint<T, Mod> N(n), R(r);
		if(N < R) return 0;

		Modint<T, Mod> imul(1);
		for(u64 i = 0; i < R; i++) {
			ret *= (N - i);
			imul *= (i + 1);
		}

		ret *= imul.inv();
		n /= Mod;
		r /= Mod;
	}

	return ret;
}

constexpr u64 MOD = 1e9 + 7;

signed main() {
	i64 n, a, b;
	std::cin >> n >> a >> b;
 
	Modint<i64, MOD> res = Modint<i64, MOD>(2).pow(n) - 1;
 
	auto cna = nCr<i64, MOD>(n, a);
	auto cnb = nCr<i64, MOD>(n, b);
 
	res -= cna;
	res -= cnb;
 
	std::cout << res << std::endl;
	
	return 0;
}


Measured memory_bytes: 384