using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace AtCoder
{
    class Program
    {
        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }

        private static CompareInfo ci = new System.Globalization.CultureInfo("ja-JP").CompareInfo;
        private static int Compare(string a, string b) { return ci.Compare(a, b, System.Globalization.CompareOptions.Ordinal); }

        class Modular
        {
            private const int M = 1000000007;
            private long value;

            public Modular(long value) { this.value = value; }
            public static implicit operator Modular(long a)
            {
                var m = a % M;
                return new Modular((m < 0) ? m + M : m);
            }
            public static Modular operator +(Modular a, Modular b) { return a.value + b.value; }
            public static Modular operator -(Modular a, Modular b) { return a.value - b.value; }
            public static Modular operator *(Modular a, Modular b) { return a.value * b.value; }
            public static Modular Pow(Modular a, int n)
            {
                switch (n)
                {
                case 0:
                    return 1;
                case 1:
                    return a;
                default:
                    var p = Pow(a, n / 2);
                    return p * p * Pow(a, n % 2);
                }
            }
            public static Modular operator /(Modular a, Modular b) { return a * Pow(b, M - 2); }
            private static readonly List<int> facs = new List<int> { 1 };
            private static Modular Fac(int n)
            {
                for (int i = facs.Count; i <= n; ++i) { facs.Add((int)(Math.BigMul(facs.Last(), i) % M)); }
                return facs[n];
            }
            public static Modular Ncr(int n, int r)
            {
                if (n < r)
                {
                    return 0;
                }
                else if (n == r)
                {
                    return 1;
                }
                else
                {
                    Modular p = 1;
                    for (int i = 0; i < r; ++i) { p *= n - i; }
                    return p / Fac(r);
                }
            }
            public static explicit operator int(Modular a) { return (int)a.value; }
        }

        static int Solve(int n, int a, int b)
        {
            var ans = Modular.Pow(2, n) - Modular.Ncr(n, a) - Modular.Ncr(n, b) - 1;
            return (int)ans;
        }

        static void Main(string[] args)
        {
            var V = ReadInts();
            Console.WriteLine(Solve(V[0], V[1], V[2]));
        }
    }
}


Measured memory_bytes: 18084