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`.)

Examples

Input

4 1 3


Output

7


Input

1000000000 141421 173205


Output

34076506
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author varunvats32
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DBouquet solver = new DBouquet();
        solver.solve(1, in, out);
        out.close();
    }

    static class DBouquet {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            int a = in.nextInt();
            int b = in.nextInt();

            DBouquet.ModInt ac = comb(n, a);
            DBouquet.ModInt bc = comb(n, b);
            DBouquet.ModInt ec = (new DBouquet.ModInt(2)).pow(n);

            DBouquet.ModInt ans = DBouquet.ModInt.subtract(ec, DBouquet.ModInt.add(ac, bc));
            out.println(DBouquet.ModInt.subtract(ans, new DBouquet.ModInt(1)).x);
        }

        private DBouquet.ModInt comb(int n, int a) {
            DBouquet.ModInt ans = new DBouquet.ModInt(1);
            for (int i = n - a + 1, j = a; i <= n; i++, j--) {
                ans.multiply(new DBouquet.ModInt(i));
                ans.divide(new DBouquet.ModInt(j));
            }
            return ans;
        }

        public static class ModInt {
            private static final int mod = 1000000007;
            public long x;

            public ModInt(long x) {
                this.x = (x % mod + mod) % mod;
            }

            public static DBouquet.ModInt add(DBouquet.ModInt a, DBouquet.ModInt b) {
                DBouquet.ModInt c = new DBouquet.ModInt(a.x);
                if ((c.x += b.x) >= mod) c.x -= mod;
                return c;
            }

            public static DBouquet.ModInt subtract(DBouquet.ModInt a, DBouquet.ModInt b) {
                DBouquet.ModInt c = new DBouquet.ModInt(a.x);
                if ((c.x += mod - b.x) >= mod) c.x -= mod;
                return c;
            }

            public DBouquet.ModInt multiply(DBouquet.ModInt a) {
                x *= a.x;
                x %= mod;
                return new DBouquet.ModInt(x);
            }

            public DBouquet.ModInt inv() {
                return pow(mod - 2);
            }

            public DBouquet.ModInt divide(DBouquet.ModInt a) {
                return this.multiply(a.inv());
            }

            public DBouquet.ModInt pow(long p) {
                if (p == 0) return new DBouquet.ModInt(1);
                DBouquet.ModInt r = pow(p >> 1);
                r = r.multiply(r);
                if ((p & 1) == 1)
                    r = r.multiply(this);
                return r;
            }

        }

    }
}

