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
input = raw_input

M = 10 ** 9 + 7
n, a, b = map(int, input().split(" "))

from math import factorial

def framod(n, mod, a=1):
    for i in range(1,n+1):
        a=a * i % mod
    return a

#power_dict = {}
# kurikaeshi jijouhou
def power(n, r, mod):
    if r == 0: return 1
    #try:
    #    ret = power_dict[(n, r)]
    #except:
    if True:
        if r%2 == 0:
            ret = power(n*n % mod, r//2, mod) % mod
        if r%2 == 1:
            ret = n * power(n, r-1, mod) % mod
        #power_dict[(n, r)] = ret
    return ret


def comb(n, k, mod):
    k = min(k, n-k)
    bunshi = 1
    bunbo = 1
    for i in range(k):
        bunshi = bunshi * (n-i)
        bunshi = bunshi % M
        bunbo = bunbo * (i+1)
        bunbo = bunbo % M

    ret = (bunshi * power(bunbo, mod-2, mod)) % mod
    #a=framod(n, mod)
    #b=framod(k, mod)
    #c=framod(n-k, mod)
    #return (a * power(b, mod-2, mod) * power(c, mod-2, mod)) % mod
    return ret

#if True:
if False:
    comb_dict = {}
    comb_dict[(1, 0)] = 1
    comb_dict[(1, 1)] = 1

    zenbu2 = 1
    for i in range(2, n+1):
        new_comb_dict = {}
        new_comb_dict[(i, 0)] = 1
        new_comb_dict[(i, i)] = 1
        for j in range(1, i):
            tmp = comb_dict[(i-1, j-1)] + comb_dict[(i-1, j)]
            tmp = tmp % M
            new_comb_dict[(i, j)] = tmp
            if i == n:
                zenbu2 += tmp

        comb_dict = new_comb_dict


#zenbu = 1
#for i in range(n):
#    zenbu = zenbu * 2
#    zenbu = zenbu % M
#
#    assert zenbu not in values, (i, zenbu)
#    values.append(zenbu)
#zenbu = zenbu2

#out = 0
#for i in range(1, n+1):
#    if i == a or i == b:
#        continue
#    tmp = comb(n, i, M)
#    out += tmp

zenbu = power(2, n, M) - 1
#print("zenbu", zenbu)
A = comb(n, a, M)
#print("A", A)
B = comb(n, b, M)
#print("B", B)

out = zenbu - A - B
#out = zenbu - comb_dict[(n, a)] - comb_dict[(n, b)]
out = out % M
print(out)