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 Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

;; D - Bouquet

(defparameter *modulus* (+ (expt 10 9) 7))

(defun solve (n a b)
  "(n 1) + (n 2) + ... + (n n) (= 2 ** n - 1) - (n a) - (n b)"
  (mod+ (modulo-expt 2 n) -1
        (- (choose n a))
        (- (choose n b))))

(defun main ()
  (let ((n (read))
        (a (read))
        (b (read)))
    (princ (solve n a b))))

;; modulo addition/product/division

(defun mod+ (&rest rest)
  (mod (apply #'+ rest) *modulus*))

(defun mod* (&rest rest)
  (mod (apply #'* rest) *modulus*))

(defun mod/ (num &rest denom)
  (apply #'mod* (cons num (mapcar #'mod-inverse denom))))

(defun bit-sequence (v)
  "(bit-sequence 13) => (1 1 0 1)"
  (nreverse
    (loop for x = v then (ash x -1) while (plusp x)
          collect (logand x 1))))

(let ((modulus-2-bits (bit-sequence (- *modulus* 2))))
  ; Mが素数のとき，a^(M-2) ≡ a^(-1) mod M (フェルマーの小定理より)
  (defun mod-inverse (a) (mod-expt-bit-seq a modulus-2-bits)))

(defun modulo-expt (a n) (mod-expt-bit-seq a (bit-sequence n)))

(defun mod-expt-bit-seq (a bit-seq)
  (loop for b in bit-seq
        for e = a then (mod* e e (if (zerop b) 1 a))
        finally (return e)))

(defun choose (n k)
  (labels ((choose-r (n k acc)
              (if (zerop k) acc
                  (choose-r (1- n) (1- k) (mod* acc (mod/ n k))))))
    (if (or (< n k) (minusp k)) 0
        (choose-r n k 1))))

(main)