# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
import copy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)


def lcm(a, b): return a * b / gcd(a, b)

# 1 2 3
# a, b, c = LI()


def LI(): return list(map(int, sys.stdin.buffer.readline().split()))

# a = I()


def I(): return int(sys.stdin.buffer.readline())

# abc def
# a, b = LS()


def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()

# a = S()


def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')

# 2
# 1
# 2
# [1, 2]


def IR(n): return [I() for i in range(n)]

# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]


def LIR(n): return [LI() for i in range(n)]

# 2
# abc
# def
# [abc, def]


def SR(n): return [S() for i in range(n)]

# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]


def LSR(n): return [LS() for i in range(n)]

# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]


def SRL(n): return [list(S()) for i in range(n)]


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


def comb(n, r):
    p, q = 1, 1
    for i in range(r):
        p = p * (n-i) % MOD
        q = q * (i+1) % MOD
    return p * pow(q, MOD-2, MOD) % MOD


ans = (pow(2, n, MOD)-1) % MOD
ans = (ans+MOD-comb(n, a)) % MOD
ans = (ans+MOD-comb(n, b)) % MOD

print(ans) from math import floor, ceil, sqrt, factorial, log, gcd from itertools import accumulate, permutations, combinations, product, combinations_with_replacement from bisect import bisect_left, bisect_right from collections import Counter, defaultdict, deque from heapq import heappop, heappush, heappushpop, heapify import copy copy import sys sys INF = float('inf') INF float('inf') float 'inf' mod = 10**9+7 mod 10**9+7 10**9 10 9 7 sys.setrecursionlimit(10 ** 6) sys.setrecursionlimit sys setrecursionlimit 10 ** 6 10 6 def lcm(a, b): return a * b / gcd(a, b)

# 1 2 3
# a, b, c = LI() lcm a a b b def LI(): return list(map(int, sys.stdin.buffer.readline().split()))

# a = I() LI def I(): return int(sys.stdin.buffer.readline())

# abc def
# a, b = LS() I def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()

# a = S() LS def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')

# 2
# 1
# 2
# [1, 2] S I() for i in range(n) for i in range(n) i range(n) range n for i in range(n) I() I def IR(n): return [I() for i in range(n)]

# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]] IR n n LI() for i in range(n) for i in range(n) i range(n) range n for i in range(n) LI() LI def LIR(n): return [LI() for i in range(n)]

# 2
# abc
# def
# [abc, def] LIR n n S() for i in range(n) for i in range(n) i range(n) range n for i in range(n) S() S def SR(n): return [S() for i in range(n)]

# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]] SR n n LS() for i in range(n) for i in range(n) i range(n) range n for i in range(n) LS() LS def LSR(n): return [LS() for i in range(n)]

# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]] LSR n n list(S()) for i in range(n) for i in range(n) i range(n) range n for i in range(n) list(S()) list S() S def SRL(n): return [list(S()) for i in range(n)] SRL n n n, a, b = map(int, input().split()) n map(int, input().split()) map int input().split() ().split () input split a b MOD = 10**9+7 MOD 10**9+7 10**9 10 9 7 def comb(n, r):
    p, q = 1, 1
    for i in range(r):
        p = p * (n-i) % MOD
        q = q * (i+1) % MOD
    return p * pow(q, MOD-2, MOD) % MOD comb p, q = 1, 1 p 1 q 1 for i in range(r):
        p = p * (n-i) % MOD
        q = q * (i+1) % MOD
     i range(r) range r p = p * (n-i) % MOD p p * (n-i) % MOD p * (n-i) p n-i n i MOD q = q * (i+1) % MOD q q * (i+1) % MOD q * (i+1) q i+1 i 1 MOD return p * pow(q, MOD-2, MOD) % MOD p * pow(q, MOD-2, MOD) % MOD p * pow(q, MOD-2, MOD) p pow(q, MOD-2, MOD) pow q MOD-2 MOD 2 MOD MOD n n r r ans = (pow(2, n, MOD)-1) % MOD ans (pow(2, n, MOD)-1) % MOD pow(2, n, MOD)-1 pow(2, n, MOD) pow 2 n MOD 1 MOD ans = (ans+MOD-comb(n, a)) % MOD ans (ans+MOD-comb(n, a)) % MOD ans+MOD-comb(n, a) ans+MOD ans MOD comb(n, a) comb n a MOD ans = (ans+MOD-comb(n, b)) % MOD ans (ans+MOD-comb(n, b)) % MOD ans+MOD-comb(n, b) ans+MOD ans MOD comb(n, b) comb n b MOD print(ans) print ans mod = 10**9+7 10**9+7 mod def lcm(a, b): return a * b / gcd(a, b)

# 1 2 3
# a, b, c = LI() def lcm(a, b): return a * b / gcd(a, b)

# 1 2 3
# a, b, c = LI() lcm def LI(): return list(map(int, sys.stdin.buffer.readline().split()))

# a = I() def LI(): return list(map(int, sys.stdin.buffer.readline().split()))

# a = I() LI def I(): return int(sys.stdin.buffer.readline())

# abc def
# a, b = LS() def I(): return int(sys.stdin.buffer.readline())

# abc def
# a, b = LS() I ans = (ans+MOD-comb(n, b)) % MOD (ans+MOD-comb(n, b)) % MOD ans def LIR(n): return [LI() for i in range(n)]

# 2
# abc
# def
# [abc, def] def LIR(n): return [LI() for i in range(n)]

# 2
# abc
# def
# [abc, def] LIR b = map(int, input().split()) map(int, input().split()) b INF = float('inf') float('inf') INF def IR(n): return [I() for i in range(n)]

# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]] def IR(n): return [I() for i in range(n)]

# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]] IR ans = (pow(2, n, MOD)-1) % MOD (pow(2, n, MOD)-1) % MOD ans def SR(n): return [S() for i in range(n)]

# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]] def SR(n): return [S() for i in range(n)]

# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]] SR def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')

# 2
# 1
# 2
# [1, 2] def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')

# 2
# 1
# 2
# [1, 2] S def LSR(n): return [LS() for i in range(n)]

# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]] def LSR(n): return [LS() for i in range(n)]

# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]] LSR ans = (ans+MOD-comb(n, a)) % MOD (ans+MOD-comb(n, a)) % MOD ans a, b = map(int, input().split()) map(int, input().split()) a def comb(n, r):
    p, q = 1, 1
    for i in range(r):
        p = p * (n-i) % MOD
        q = q * (i+1) % MOD
    return p * pow(q, MOD-2, MOD) % MOD def comb(n, r):
    p, q = 1, 1
    for i in range(r):
        p = p * (n-i) % MOD
        q = q * (i+1) % MOD
    return p * pow(q, MOD-2, MOD) % MOD comb def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()

# a = S() def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()

# a = S() LS def SRL(n): return [list(S()) for i in range(n)] def SRL(n): return [list(S()) for i in range(n)] SRL n, a, b = map(int, input().split()) map(int, input().split()) n MOD = 10**9+7 10**9+7 MOD
# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
import copy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)


def lcm(a, b): return a * b / gcd(a, b)

# 1 2 3
# a, b, c = LI()


def LI(): return list(map(int, sys.stdin.buffer.readline().split()))

# a = I()


def I(): return int(sys.stdin.buffer.readline())

# abc def
# a, b = LS()


def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()

# a = S()


def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')

# 2
# 1
# 2
# [1, 2]


def IR(n): return [I() for i in range(n)]

# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]


def LIR(n): return [LI() for i in range(n)]

# 2
# abc
# def
# [abc, def]


def SR(n): return [S() for i in range(n)]

# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]


def LSR(n): return [LS() for i in range(n)]

# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]


def SRL(n): return [list(S()) for i in range(n)]


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


def comb(n, r):
    p, q = 1, 1
    for i in range(r):
        p = p * (n-i) % MOD
        q = q * (i+1) % MOD
    return p * pow(q, MOD-2, MOD) % MOD


ans = (pow(2, n, MOD)-1) % MOD
ans = (ans+MOD-comb(n, a)) % MOD
ans = (ans+MOD-comb(n, b)) % MOD

print(ans)
