Problem:
Score : 400 points

Problem Statement

Akari has n kinds of flowers, one of each kind.

She is going to choose one or more of these flowers to make a bouquet.

However, she hates two numbers a and b, so the number of flowers in the bouquet cannot be a or b.

How many different bouquets are there that Akari can make?

Find the count modulo (10^9 + 7).

Here, two bouquets are considered different when there is a flower that is used in one of the bouquets but not in the other bouquet.

Constraints

All values in input are integers.

2 \leq n \leq 10^9

1 \leq a < b \leq \textrm{min}(n, 2 \times 10^5)

Input

Input is given from Standard Input in the following format:

n a b

Output

Print the number of bouquets that Akari can make, modulo (10^9 + 7). (If there are no such bouquets, print 0.)

Sample Input 1

4 1 3

Sample Output 1

7

In this case, Akari can choose 2 or 4 flowers to make the bouquet.

There are 6 ways to choose 2 out of the 4 flowers, and 1 way to choose 4, so there are a total of 7 different bouquets that Akari can make.

Sample Input 2

1000000000 141421 173205

Sample Output 2

34076506

Print the count modulo (10^9 + 7).

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main(string[] args)
    {
        var input = Console.ReadLine().Split().Select(int.Parse).ToList();
        var n = input[0];
        var a = input[1];
        var b = input[2];
        var result = new Mint(2).Pow(n);
        result -= 1;
        result -= Mint.Combination(n, a);
        result -= Mint.Combination(n, b);
        Console.WriteLine(result);
    }
}

public class Mint
{
    public const long Mod = (long)1e9 + 7;
    public long Number { get; private set; }
    public Mint Inv => Pow(Mod - 2);

    public Mint(long number = 0)
    {
        Number = (number % Mod + Mod) % Mod;
    }

    public Mint Pow(long t)
    {
        if (t == 0)
        {
            return new Mint(1);
        }

        var result = Pow(t >> 1);
        result *= result;

        if ((t & 1) > 0)
        {
            result *= this;
        }

        return result;
    }

    public static Mint Combination(Mint m, Mint n)
        => Permutation(m, n) / Permutation(n, n);

    public static Mint Permutation(Mint m, Mint n)
        => Enumerable.Range(m - n + 1, n).Select(target => new Mint(target)).Aggregate((a, b) => a * b);

    public static Mint operator +(Mint m) => m;
    public static Mint operator -(Mint m) => new Mint(-m.Number);
    public static Mint operator +(Mint a, Mint b) => new Mint(a.Number + b.Number);
    public static Mint operator -(Mint a, Mint b) => new Mint(a.Number - b.Number);
    public static Mint operator *(Mint a, Mint b) => new Mint(a.Number * b.Number);
    public static Mint operator /(Mint a, Mint b) => a * b.Inv;
    public static implicit operator Mint(long i) => new Mint(i);
    public static implicit operator Mint(int i) => new Mint(i);
    public static implicit operator long(Mint m) => m.Number;
    public static implicit operator int(Mint m) => (int)m.Number;
    public override string ToString() => Number.ToString();
}