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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
#define fi first
#define se second

typedef long long ll;
typedef long double ld;
using namespace std;
#define int long long
const int N = (int)2e6 + 10;
int fact[N];
int inv[N];
const int mod = (int)1e9 + 7;
int pow(int a , int b){
    if(b == 0)return 1;
    int ans = pow(a , b / 2);
    ans = (1ll * ans * ans) % mod;
    if(b&1)ans = (1ll * ans * a) % mod;
    return ans;
}
int inverse(int x){
    return pow(x , mod - 2);
}
int f(int x , int y){
    return (int)(((1ll*(1ll*fact[x+y]*inv[x])%mod)*inv[y])%mod);
}
int stupid(int x , int y){
    int answer =0;
    for(int i = 0 ; i <= x; ++i)
        for(int j = 0 ; j <= y; ++j)
            {answer += f(i , j) ; if(answer >= mod)answer-=mod;}
    return answer;
}
int calc(int x , int y){
    int ans = 0;
    for(int i = 1; i <= x + 1;++i){
        ans += f(i , y); if(ans >= mod)ans-=mod;
    }
//    assert(stupid(x , y) == ans);
    return ans;
}
int sub(int x,  int y){
    int ans = x - y + mod;
    while(ans >= mod)ans -= mod;
    return ans;
}
void preproc(){
    fact[0] = 1;
    for(int i = 1; i  < N ; ++i){
        fact[i] = (1ll * fact[i - 1] * i) % mod;
    }
    for(int i = 0 ; i < N; ++i)
        inv[i] = inverse(fact[i]);
}
signed main(){
    preproc();
    int r1 , r2 , c1 , c2; cin >> r1 >> c1 >> r2 >> c2;
    int answer = sub(sub(calc(r2 , c2),calc(r1 - 1 , c2)),calc(r2,c1-1))+calc(r1-1,c1-1);
    while(answer >= mod)--answer;
    cout << answer;
    return 0;
}