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: Wrong Answer)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;

namespace A
{
    class StartingPoint
    {
        static void Main(string[] args)
        {
            if (args?.Any() == true)
            {
                var assembly = Assembly.GetEntryAssembly();
                var resourceName = "AtCoderCSharp.In.txt";
                var stream = assembly.GetManifestResourceStream(resourceName);
                var streamReader = new StreamReader(stream, Encoding.UTF8);
                var str = streamReader.ReadToEnd();
                var textReader = new StringReader(str);
                Console.SetIn(textReader);
            }

            try
            {
                foreach (var s in new Program().Solve())
                {
                    Console.WriteLine(s);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                if (args?.Any() != true)
                    throw e;
            }

            if (args?.Any() == true)
                Console.ReadKey();
        }
    }

    class Program
    {
        public List<int> ScanInts(int count) => Enumerable.Range(0, count).Select(_ => ScanInt).ToList();
        public List<int> ScanInts(long count) => ScanInts((int)count);
        public List<long> ScanLongs(int count) => Enumerable.Range(0, count).Select(_ => Scan).ToList();
        public List<long> ScanLongs(long count) => ScanLongs((int)count);
        public int ScanInt => int.Parse(Str);
        public long Scan => long.Parse(Str);
        public double ScanDouble => (double)Scan;

        StringBuilder sb = new StringBuilder();

        public string Str => ScanStr();
        public string ScanStr()
        {
            sb.Clear();

            int r = 0;
            bool? b = null;
            do
            {
                r = Console.Read();
                b = IsBreak(r);
            } while (b == true);

            if (b == null)
                throw new Exception("input error: unexpected end of stream");

            do
            {
                sb.Append((char)r);
                r = Console.Read();
                b = IsBreak(r);
            } while (b == false);

            return sb.ToString();
        }

        bool? IsBreak(int c)
        {
            switch (c)
            {
                case -1:
                    return null;
                case (int)' ':
                case (int)'\n':
                case (int)'\r':
                    return true;
                default:
                    return false;
            }
        }

        public IEnumerable<int> Loop(int count) => Enumerable.Range(0, count);
        public IEnumerable<int> Loop(int from, int to) => Enumerable.Range(from, to - from + 1);

        public IEnumerable<long> Loop(long count) => Loop(0, count - 1);
        public IEnumerable<long> Loop(long from, long to)
        {
            for (long i = from; i <= to; i++)
                yield return i;
        }

        public string YesNo(bool isYes) => isYes ? "Yes" : "No";

        public HashSet<T> ToHashSet<T>(IEnumerable<T> ts) => new HashSet<T>(ts);



        struct Mint
        {
            public static long Divider { set { divider = value; } }
            private static long divider = 1000000007;
            public static void Set998244353() { divider = 998244353; }

            public long Value { get; }

            public Mint(long value)
            {
                this.Value = value;
            }

            public static Mint operator +(Mint a, Mint b) => new Mint((a.Value + b.Value) % divider);

            public static Mint operator -(Mint a, Mint b)
            {
                var t = (a.Value - b.Value) % divider;
                if (t < 0)
                    t += divider;
                return new Mint(t);
            }

            public static Mint operator *(Mint a, Mint b) => new Mint((a.Value * b.Value) % divider);

            public static Mint operator /(Mint a, Mint b) => new Mint((a.Value * InvImpl(b.Value)) % divider);

            public Mint Pow(long p) => new Mint(PowImpl(Value, p));
            private static long PowImpl(long a, long p)
            {
                if (p == 0)
                    return 1L;

                if (p == 1)
                    return a;

                var halfP = p / 2;
                var halfPowered = PowImpl(a, halfP);
                var powered = halfPowered * halfPowered % divider;
                return p % 2 == 0 ? powered : powered * a % divider;
            }

            public static Mint Inv(long a) => new Mint(InvImpl(a));
            private static readonly Dictionary<long, long> invCache = new Dictionary<long, long>();
            private static long InvImpl(long a)
            {
                long cache = 0L;
                if (invCache.TryGetValue(a, out cache))
                    return cache;

                var result = PowImpl(a, divider - 2);
                invCache.Add(a, result);
                return result;
            }

            public static Mint Fac(long a) => new Mint(FacImpl(a));
            //private static readonly List<long> facCache = new List<long>() { 1L };
            private static long FacImpl(long a)
            {
                if (a >= divider)
                    return 0;

                var val = 1L;
                var start = 1;
                for (int i = start; i <= a; i++)
                {
                    val = (val * i) % divider;
                }

                return val;
            }

            public static Mint Perm(long n, long r) => new Mint(PermImpl(n, r));
            private static long PermImpl(long n, long r)
            {
                if (n < r)
                    return 0L;

                if (r <= 0)
                    return 1L;

                var nn = FacImpl(n);
                var nr = FacImpl(n - r);
                return (nn * InvImpl(nr)) % divider;
            }

            public static Mint Comb(long n, long r) => new Mint(CombImpl(n, r));
            private static long CombImpl(long n, long r)
            {
                if (n < r)
                    return 0L;

                if (n == r)
                    return 1L;

                var nn = FacImpl(n);
                var nr = FacImpl(n - r);
                var rr = FacImpl(r);

                var nndnr = (nn * InvImpl(nr)) % divider;
                return (nndnr * InvImpl(rr)) % divider;
            }
        }


        public IEnumerable<string> Solve()
        {
            var n = ScanInt;
            var a = ScanInt;
            var b = ScanInt;

            var f = new Mint(2).Pow(n) - new Mint(1);


            var val = 1L;
            var start = 1;
            long fn = 0, fna = 0, fa = 0, fnb = 0, fb = 0;

            for (long i = start; i <= n; i++)
            {
                val = (val * i) % 1000000007;

                if (i == n)
                    fn = val;
                if (i == n - a)
                    fna = val;
                if (i == a)
                    fa = val;
                if (i == n - b)
                    fnb = val;
                if (i == b)
                    fb = val;
            }

            var aa = new Mint(fn) / new Mint(fna) / new Mint(fa);
            var bb = new Mint(fn) / new Mint(fnb) / new Mint(fb);
            var res = f - aa - bb;

            yield return res.Value.ToString();
        }
    }
}