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 Scala (2.11.7) (judge verdict: Wrong Answer)

object Main extends App {
	val Array(n, a, b) = scala.io.StdIn.readLine.split(" ").map(_.toLong)

	val p = 1000000007L

	var tp = 1L

	val p1 = powMod(2L, n, p)
	val p2 = combi(n, a, p)
	val p3 = combi(n, b, p)

	val ans = p1 - p2 - p3 - 1

	if(ans < 0) println((p + ans)%p)
	else println(ans%p)


	def combi(n: Long, r: Long, p: Long): BigInt = {
		val tp1 = (n - r + 1L to n).foldLeft(1L)((z, i) => z*i % p)
		return (1L to r).foldLeft(BigInt(tp1))((z, i) => BigInt(i).modInverse(p) * z % p)
	}


	def powMod(a: Long, n: Long, p: Long): Long = {
    	def subpowMod(a: Long, n: Long, mul: Long): Long = {
    		n match{
				case 1L => a * mul % p
				case _  => subpowMod(a*a%p, n/2, mul * (if((n&1) == 1) a else 1) % p )
    		}
    	}
    	subpowMod(a, n, 1L).toInt
  	}

}