module app;

import core.bitop;

import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.stdio;
import std.string;
import std.traits;

struct Input
{
    ulong n;
	int a, b;
}

void parseInput(T)(out Input input, T file)
{
	with (file) with (input)
	{
		auto ar = readln().strip().split().map!(to!int).array();
		n = ar[0].to!int;
		a = ar[1].to!int;
		b = ar[2].to!int;
	}
}

alias ModLong = Mod!(long, 10 ^^ 9 + 7);

auto main2(Input* input)
{
	with (input)
	{
        ModLong sum = 2;
        sum ^^= n;
        sum -= combinationMod(n, a);
        sum -= combinationMod(n, b);
        sum -= 1;
        return sum.value;
	}
}

auto combinationMod(ulong n, ulong r)
{
    ModLong numerator = 1;
    foreach (i; (n-r+1)..(n+1))
        numerator *= i;
    ModLong denominator = 1;
    foreach (i; 1..(r+1))
        denominator *= i;
    denominator ^^= (10^^9+7-2);
    return numerator * denominator;
}

alias retType = ReturnType!main2;
static if (!is(retType == void))
{
	unittest { writeln("begin unittest"); }
	auto _placeholder_ = ReturnType!main2.init;

	unittest // example1
	{
		string example =
`4 1 3`;
		if (example.empty) return;
		Input input = void;
		parseExample(input, example);
		auto result = main2(&input);
		printResult(result);
		assert(result == 7);
	}

	unittest // example2
	{
		string example =
`1000000000 141421 173205`;
		if (example.empty) return;
		Input input = void;
		parseExample(input, example);
		auto result = main2(&input);
		printResult(result);
		assert(result == 34076506);
	}

	unittest { writeln("end unittest"); }

	void parseExample(out Input input, string example)
	{
		struct Adapter
		{
			string[] _lines;
			this(string input) { _lines = input.splitLines(); }
			string readln() { auto line = _lines[0]; _lines = _lines[1..$]; return line; }
		}
		parseInput(input, Adapter(example));
	}
}

void printResult(T)(T result)
{
	static if (isFloatingPoint!T) writefln("%f", result);
	else writeln(result);
}

void main()
{
	Input input = void;
	parseInput(input, stdin);
	alias retType = ReturnType!main2;
	static if (is(retType == void))
		main2(&input);
	else
	{
		auto result = main2(&input);
		printResult(result);
	}
}

struct Mod(T, T m)
if ((is(T : int) || is(T : long)) && m > 0 && m ^^ 2 <= T.max)
{
    private T _value;
    invariant { assert(_value >= 0); }
    this(T t) { opAssign(t); }
    void opAssign(T t) { _value = t % m; }
    void opAssign(typeof(this) mod) { opAssign(mod._value); }
    typeof(this) opBinary(string op)(T t)
    {
        static if (op == "*")
        {
            typeof(this) result;
            result = _value * t;
            return result;
        }
        else static if (op == "^^")
        {
            if (t <= 0)
                assert(0);
            else if (t == 1)
                return this;
            else if (t % 2 == 1)
                return this * (this ^^ (t - 1));
            else
            {
                auto temp = this ^^ (t / 2);
                return temp * temp;
            }
        }
        else static if (op == "-")
        {
            auto temp = _value - t % m;
            if (temp < 0)
                temp += m;
            typeof(this) result = temp;
            return result;
        }
        else static assert(0);
    }
    typeof(this) opBinary(string op)(typeof(this) mod) { return opBinary!op(mod._value); }
    void opOpAssign(string op)(T t) { this = this.opBinary!op(t); }
    void opOpAssign(string op)(typeof(this) mod) { opOpAssign!op(mod._value); }
    bool opEquals()(auto ref const T t) const { return _value == t; }
    bool opEquals()(auto ref const typeof(this) mod) const { return opEquals(mod._value); }
    T value() const { return _value; }
}