Problem:
Score : 400 points

Problem Statement

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

Sample Input 1

4 1 3

Sample Output 1

7

In this case, Akari can choose 2 or 4 flowers to make the bouquet.

There are 6 ways to choose 2 out of the 4 flowers, and 1 way to choose 4, so there are a total of 7 different bouquets that Akari can make.

Sample Input 2

1000000000 141421 173205

Sample Output 2

34076506

Print the count modulo (10^9 + 7).

Solution in PyPy3 (2.4.0) (judge verdict: Wrong Answer)

from __future__ import print_function

import sys

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction
from fractions import gcd
# fractions.gcd() を用いること
# math.log2()はatcoderでは対応していない．留意せよ．

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


def lcm(n, m):
    return int(n * m / gcd(n, m))


def coprimize(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def find_gcd(list_l):
    x = reduce(gcd, list_l)
    return x


p = 10**9+7

def cmb(n, r):
    temp1 = 1
    temp2 = 1
    for i in range(n-r+1, n+1):
        temp1 *= i
        temp1 %= p
    for i in range(1, r+1):
        temp2 *= i
        temp2 %= p
    return temp1 * pow(temp2,p-2,p) % p 


def main():
    n, a, b = map(int, input().strip().split())    
    # eprint('pow(2,n,p) - cmb(n, a) - cmb(n, b) - 1 ',end=':\n')
    # eprint(pow(2,n,p) - cmb(n, a) - cmb(n, b) - 1)

    # eprint('pow(2,n,p) ',end=':\n')
    # eprint(pow(2,n,p))
    # eprint('cmb(n,a) ',end=':\n')
    # eprint(cmb(n,a))
    # eprint('cmb(n,b) ',end=':\n')
    # eprint(cmb(n,b))

    # if pow(2,n,p) - cmb(n, a) - cmb(n, b) - 1<-1:
    #     print(pow(2,n,p) - cmb(n, a) - cmb(n, b) - 1 + p)
    # elif pow(2,n,p) - cmb(n, a) - cmb(n, b) - 1 == -1:
    #     print(0)
    # else:
    #     print(max( (pow(2,n,p) - cmb(n, a) - cmb(n, b) - 1) , 0 ))

    #
    eprint('pow(2,n,p) ',end=':\n')
    eprint(pow(2,n,p))

    #
    xxx = pow(2,n,p) - cmb(n, a) - cmb(n, b)
    if xxx<0:
        print(xxx-1+p)
    elif xxx == 0:
        print(0)
    else:
        print(xxx-1)


if __name__ == '__main__':
    main()