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 Kotlin (1.0.0) (judge verdict: Time Limit Exceeded)

const val P = 1000000007L

// Find (x, y, r) such that r = gcd(a,b) and ax + by = r.
fun extendedGCD(a: Long, b: Long): Triple<Long, Long, Long> {
    var x0 = 1L
    var y0 = 0L
    var z0 = a
    var x1 = 0L
    var y1 = 1L
    var z1 = b
    while (true) {
        if (z1 == 0L) return Triple(x0, y0, z0)
        val q = z0 / z1
        val x2 = x0 - q * x1
        val y2 = y0 - q * y1
        val z2 = z0 - q * z1
        x0 = x1
        x1 = x2
        y0 = y1
        y1 = y2
        z0 = z1
        z1 = z2
    }
}

fun modInverse(a: Long, m: Long): Long {
    val (x, y, r) = extendedGCD(a, m)
    if (r != 1L) return 0  // No inverse.

    return (x + m) % m
}

class FiniteField(val x: Long) {
    constructor(xi: Int): this(xi.toLong())
    operator fun plus(o: Long) = FiniteField((x + o) % P)
    operator fun plus(o: FiniteField) = this + o.x
    operator fun minus(o: Long) = FiniteField((x + P - o) % P)
    operator fun minus(o: FiniteField) = this - o.x
    operator fun times(o: Long) = FiniteField((x * o) % P)
    operator fun times(o: FiniteField) = this * o.x
    operator fun div(o: Long) = this * modInverse(o, P)
    operator fun div(o: FiniteField) = this / o.x
    override fun toString() = x.toString()
}

fun main(args: Array<String>) {
    val (r1, c1, r2, c2) = readLine()!!.split(" ").map { it.toInt() }

    val n = r2 + c2 + 2
    val factorials = Array(n + 1, { FiniteField(0) })
    factorials[0] = FiniteField(1)
    for (i in 1..n) {
        factorials[i] = factorials[i - 1] * FiniteField(i)
    }
    val iFactorials = Array(n + 1, { FiniteField(0) })
    for (i in 0..n) {
        iFactorials[i] = FiniteField(1) / factorials[i]
    }

    fun combination(a: Int, b: Int): FiniteField {
        if (a < b) return FiniteField(0)
        return factorials[a] * iFactorials[b] * iFactorials[a - b]
    }

    fun solve(r: Int, c: Int): FiniteField {
        if (r == 0 || c == 0) return FiniteField(Math.max(r, c) + 1)
        var rv = FiniteField(0)
        for (i in 0..r) {
            rv += combination(c + i + 1, i + 1)
        }
        return rv
    }
    val ans = solve(r2, c2) - solve(r1 - 1, c2) - solve(r2, c1 - 1) + solve(r1 - 1, c1 - 1)
    println(ans)
}