#include <bits/stdc++.h>
using namespace std;

using i64 = int64_t;

#define rep(i, x, y) for (i64 i = i64(x), i##_max_for_repmacro = i64(y); i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif

template <i64 p>
class fp {
    public:
    i64 x;
    fp() : x(0) {}
    fp(i64 x_) : x((x_ % p + p) % p) {}
    fp operator+() const { return fp(x); }
    fp operator-() const { return fp(-x); }
    fp& operator+=(const fp& y) {
        x += y.x;
        if (x >= p) x -= p;
        return *this;
    }
    fp& operator-=(const fp& y) { return *this += -y; }
    fp& operator*=(const fp& y) {
        x = x * y.x % p;
        return *this;
    }
    fp& operator/=(const fp& y) { return *this *= fp(inverse(y.x)); }
    fp operator+(const fp& y) const { return fp(x) += y; }
    fp operator-(const fp& y) const { return fp(x) -= y; }
    fp operator*(const fp& y) const { return fp(x) *= y; }
    fp operator/(const fp& y) const { return fp(x) /= y; }
    bool operator==(const fp& y) const { return x == y.x; }
    bool operator!=(const fp& y) const { return !(*this == y); }
    i64 extgcd(i64 a, i64 b, i64& x, i64& y) {
        i64 d = a;
        if (b != 0) {
            d = extgcd(b, a % b, y, x);
            y -= (a / b) * x;
        } else {
            x = 1;
            y = 0;
        }
        return d;
    }
    i64 inverse(i64 a) {
        i64 x, y;
        extgcd(a, p, x, y);
        return (x % p + p) % p;
    }
};

template <i64 p>
i64 abs(const fp<p>& x) { return x.x; }

template <i64 p>
ostream& operator<<(ostream& os, const fp<p>& x) {
    os << x.x;
    return os;
}

template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    os << "(" << p.first << ", " << p.second << ")";
    return os;
}

template <typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
    os << "[";
    for (const auto& v : vec) {
        os << v << ",";
    }
    os << "]";
    return os;
}

template <typename T>
bool chmin(T& a, const T& b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

template <typename T>
bool chmax(T& a, const T& b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

template <typename A, typename T, size_t size>
void fill(A (&ary)[size], const T& val) {
    fill((T*)ary, (T*)(ary + size), val);
}

// x未満の要素の個数を返す
template <typename T>
i64 count_less(const vector<T>& v, T x) {
    return lower_bound(begin(v), end(v), x) - begin(v);
}

// x以下の要素の個数を返す
template <typename T>
i64 count_less_or_equal(const vector<T>& v, T x) {
    return upper_bound(begin(v), end(v), x) - begin(v);
}

// xより大きい要素の個数を返す
template <typename T>
i64 count_greater(const vector<T>& v, T x) {
    return end(v) - upper_bound(begin(v), end(v), x);
}

// x以上の要素の個数を返す
template <typename T>
i64 count_greater_or_equal(const vector<T>& v, T x) {
    return end(v) - lower_bound(begin(v), end(v), x);
}

// x未満の要素のうち最大のものを返す
template <typename T>
T max_less(const vector<T>& v, T x) {
    return *(lower_bound(begin(v), end(v), x) - 1);
}

// x以下の要素のうち最大のものを返す
template <typename T>
T max_less_or_equal(const vector<T>& v, T x) {
    return *(upper_bound(begin(v), end(v), x) - 1);
}

// xより大きい要素のうち最小のものを返す
template <typename T>
T min_greater(const vector<T>& v, T x) {
    return *upper_bound(begin(v), end(v), x);
}

// x以上の要素のうち最小のものを返す
template <typename T>
T min_greater_or_equal(const vector<T>& v, T x) {
    return *lower_bound(begin(v), end(v), x);
}

constexpr int inf = 1.01e9;
constexpr i64 inf64 = 4.01e18;
constexpr double eps = 1e-9;

class combination {
private:
    bool has_inited = false;
    i64 p;

    i64 extgcd(i64 a, i64 b, i64 &x, i64 &y) {
        i64 d = a;
        if (b != 0) {
            d = extgcd(b, a % b, y, x);
            y -= (a / b) * x;
        } else {
            x = 1;
            y = 0;
        }
        return d;
    }

    i64 mod_inverse(i64 a, i64 m) {
        i64 x, y;
        if (extgcd(a, m, x, y) == 1) return (x + m) % m;
        return 0;
    }

    vector<i64> fact, ifact;

    void init_fact(i64 n, i64 m) {
        fact.resize(n + 1);
        ifact.resize(n + 1);
        fact[0] = fact[1] = 1;
        ifact[0] = ifact[1] = 1;
        for (i64 i = 2; i <= n; ++i) {
            fact[i] = (i * fact[i - 1]) % m;
            ifact[i] = mod_inverse(fact[i], m);
        }
    }

public:
    combination(i64 p) : p(p) {}

    combination(i64 n, i64 p) : p(p) {
        init(n);
    }

    /*
     * n以下の階乗の値を前計算する
     * O(nlog(p))
     */
    void init(i64 n) {
        has_inited = true;
        init_fact(n, p);
    }

    /*
     * 階乗の値を前計算しておいた場合はO(1)
     * 前計算していない場合はO(k+log(p))
     * */
    i64 comb(i64 n, i64 k) {
        if (n < 0 or k < 0 or n < k) return 0;
        if (has_inited) return fact[n] * ifact[n - k] % p * ifact[k] % p;

        i64 num = 1, den = 1;
        for (i64 i = 0; i < k; ++i) {
            num = num * ((n - i) % p) % p;
            den = den * (i + 1) % p;
        }
        return num * mod_inverse(den, p) % p;
    }
};

void solve() {
    constexpr i64 mod = 1'000'000'007;

    i64 r1,c1,r2,c2;
    cin >> r1 >> c1 >> r2 >> c2;

    constexpr i64 maxr=2000001;
    combination comb(maxr,mod);

    auto f=[&](i64 r,i64 c){
        return comb.comb(r+c,r);
    };

    auto g=[&](i64 r,i64 c){
        fp<mod> res;
        rep(i,0,r+1) res+=f(i+1,c);
        return res;
    };

    const auto ans=g(r2,c2)-g(r2,c1-1)-g(r1-1,c2)+g(r1-1,c1-1);
    cout << ans << endl;
}

int main() {
    std::cin.tie(0);
    std::ios::sync_with_stdio(false);
    cout.setf(ios::fixed);
    cout.precision(16);
    solve();
    return 0;
}


Measured memory_bytes: 31488