Problem:
Score : 600 points

Problem Statement

Snuke is standing on a two-dimensional plane. In one operation, he can move by 1 in the positive x-direction, or move by 1 in the positive y-direction.

Let us define a function f(r, c) as follows:

f(r,c) := (The number of paths from the point (0, 0) to the point (r, c) that Snuke can trace by repeating the operation above)

Given are integers r_1, r_2, c_1, and c_2.
Find the sum of f(i, j) over all pair of integers (i, j) such that r_1 ≤ i ≤ r_2 and c_1 ≤ j ≤ c_2, and compute this value modulo (10^9+7).

Constraints

1 ≤ r_1 ≤ r_2 ≤ 10^6

1 ≤ c_1 ≤ c_2 ≤ 10^6

All values in input are integers.

Input

Input is given from Standard Input in the following format:

r_1 c_1 r_2 c_2

Output

Print the sum of f(i, j) modulo (10^9+7).

Sample Input 1

1 1 2 2

Sample Output 1

14

For example, there are two paths from the point (0, 0) to the point (1, 1): (0,0) → (0,1) → (1,1) and (0,0) → (1,0) → (1,1), so f(1,1)=2.

Similarly, f(1,2)=3, f(2,1)=3, and f(2,2)=6. Thus, the sum is 14.

Sample Input 2

314 159 2653 589

Sample Output 2

602215194

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

;; F - Many Many Paths

(defparameter *modulus* (+ (expt 10 9) 7))
(defparameter *max-rc* (expt 10 6))

(defun main ()
  (let ((r1 (read))
        (c1 (read))
        (r2 (read))
        (c2 (read)))
    (princ (solve r1 c1 r2 c2))))

(defun solve (r1 c1 r2 c2)
  ; f(r,c) == choose(r+c, r)
  ; sum_{r=0}^{r2} sum_{c=0}^{c2} f(r,c) == f(r+1, c+1) - 1
  (labels ((f (r c) (choose (+ r c) r)))
    (mod+ (f (1+ r2) (1+ c2))
          (- (f (1+ r2) c1))
          (- (f r1 (1+ c2)))
          (f r1 c1))))

;; 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)
    (loop for b in modulus-2-bits
          for e = a then (mod* e e (if (zerop b) 1 a))
          finally (return e))))

(let* ((max-n (+ *max-rc* *max-rc* 2))
       (fact (make-array (1+ max-n)))) ; 階乗
  (setf (aref fact 0) 1) ; 0! = 1
  (loop for i from 1 to max-n
     do (setf (aref fact i) (mod* (aref fact (1- i)) i)))
  (defun choose (n k)
    (mod/ (aref fact n) (aref fact k) (aref fact (- n k)))))

(main)