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.io.IOException;
import java.io.InputStreamReader;
import java.util.Objects;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

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

    static class DBouquet {
        long mod = 1_000_000_007;

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            long n = in.nextInt();
            long a = in.nextInt();
            long b = in.nextInt();
            long res = power(n);
            long tmp = (mod - comb(a, n)) % mod;
            res += tmp;
            res %= mod;
            tmp = (mod - comb(b, n)) % mod;
            res += tmp;
            res %= mod;

            // d(comb(1, 3));

        /*long res = 0;
        for (int k=0; k<=n; k++) {
            if (k!=a && k!=b) {
                res += comb(a, n);
                res %= mod;
            }
        }*/
            out.println(res - 1);
        }

        private long comb(long a, long n) {
            long res = 1;
            for (int k = 1; k <= a; k++) {
                res *= n - k + 1;
                res %= mod;
                long tmp = inverse(k);
                tmp = (mod + (tmp % mod)) % mod;
                res *= tmp;
                res %= mod;
            }
            return res;
        }

        DBouquet.MyPair gcd(int a, int b) {
            DBouquet.MyPair res;
            if (a == 0) {
                return new DBouquet.MyPair(0, 1);
            }
            DBouquet.MyPair d = gcd(b % a, a);
            return new DBouquet.MyPair(d.second - (b / a) * d.first, d.first);
        }

        private long inverse(long val) {
            DBouquet.MyPair res = gcd((int) val, (int) mod);
            return res.first;
        }

        private long power(long n) {
            if (n == 0)
                return 1;
            long res = power(n / 2);

            if (n % 2 == 0) {
                res = res * res;
                res %= mod;
            } else {
                res = res * res;
                res %= mod;
                res *= 2;
                res %= mod;
            }
            return res;
        }

        public static class MyPair implements Comparable<DBouquet.MyPair> {
            int first;
            int second;

            public MyPair(int first, int second) {
                this.first = first;
                this.second = second;
            }

            public String toString() {
                return "[" + first + ", " + second + "]";
            }

            public boolean equals(Object o) {
                if (this == o) return true;
                if (o == null || getClass() != o.getClass()) return false;
                DBouquet.MyPair myPair = (DBouquet.MyPair) o;
                return first == myPair.first &&
                        second == myPair.second;
            }

            public int hashCode() {
                return Objects.hash(first, second);
            }

            public int compareTo(DBouquet.MyPair p2) {
                return first - p2.first != 0 ? first - p2.first : this.second - p2.second;
            }

        }

    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader(InputStream in) {
            this(new InputStreamReader(in));
        }

        public FastReader(InputStreamReader input) {
            br = new BufferedReader(input);
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    String s = br.readLine();
                    if (s == null)
                        return null;
                    st = new StringTokenizer(s);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

