#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(n); i++)
#define all(x) (x).begin(), (x).end()
#define bit(x) (1L << (x))
using ll = long long;
using namespace std;

template<typename T>
vector<T> make_v(size_t a,T b){return vector<T>(a,b);}
 
template<typename... Ts>
auto make_v(size_t a,Ts... ts){
        return vector<decltype(make_v(ts...))>(a,make_v(ts...));
}

constexpr int default_mod = 1e9 + 7;
constexpr bool default_isPrime = true;

template<int Mod = default_mod, bool IsPrime = default_isPrime>
class mint {
        ll n_;
public:
        constexpr mint(ll n): n_{n} { 
                if (n >= Mod) {
                        n_ %= Mod;
                } else {
                        n_ = (n_ % Mod + Mod) % Mod;
                }
        }

        constexpr mint() : n_{0} {}

        constexpr operator int() const { return n_; }
        constexpr operator ll() const { return n_; }

        constexpr mint& operator==(const mint& n) {
                return n_ == n.n_;
        }

        constexpr mint& operator=(const mint& n) {
                n_ = n.n_;
                return *this;
        }

        constexpr mint& operator+=(const mint& n) {
                if ((n_ += n.n_) >= Mod) n_ -= Mod;
                return *this;
        }

        constexpr mint& operator-=(const mint& n) {
                if ((n_ -= n.n_) < 0) n_ += Mod;
                return *this;
        }
        
        constexpr mint& operator*=(const mint& n) {
                if ((n_ *= n.n_) >= Mod) n_ %= Mod;
                return *this;
        }

        constexpr mint& operator/=(const mint& n) {
                return *this *= n.inverse();
        }

        constexpr typename enable_if<IsPrime, mint>::type inverse() const {
                ll a = n_, b = Mod, u = 1, v = 0;
                while (b) {
                        ll t = a / b;
                        a -= t * b; swap(a, b);
                        u -= t * v; swap(u, v);
                }
                return mint(u);
        }

        constexpr mint operator+(mint n) const { return mint(*this) += n; }
        constexpr mint operator-(mint n) const { return mint(*this) -= n; }
        constexpr mint operator*(mint n) const { return mint(*this) *= n; }
        constexpr mint operator/(mint n) const { return mint(*this) /= n; }

};

template<int Mod = default_mod, bool IsPrime = default_isPrime>
ostream& operator<<(ostream& os, mint<Mod, IsPrime> const& n) {
        os << (int)n;
        return os;
}

template<int Mod = default_mod, bool IsPrime = default_isPrime>
mint<Mod, IsPrime> fact(int n) {
        static vector<mint<Mod, IsPrime>> v {1};

        if (n >= static_cast<int>(v.size())) {
                const int from = v.size(), to = n + 1024;
                v.reserve(to);
                for (int i = from; i < to; i++) {
                        v.push_back(v.back() * mint<Mod, IsPrime>(i));
                }
        }
        
        return v[n];
}

template<int Mod = default_mod, bool IsPrime = default_isPrime>
mint<Mod, IsPrime> comb(int n, int r) {
        if (r < 0 || n < r) {
                return 0;
        } else {
                return fact<Mod, IsPrime>(n) / fact<Mod, IsPrime>(r) / fact<Mod, IsPrime>(n - r);
        }
}

using mi = mint<>;

int main() {
        int r1, c1, r2, c2;
        cin >> r1 >> c1 >> r2 >> c2;
        
        mi s(0);
        s += comb(r2 + c2 + 2, r2 + 1);
        s -= comb(r2 + c1 + 1, r2 + 1);
        s -= comb(r1 + c2 + 1, r1);
        s += comb(r1 + c1, c1);
        cout << s << endl;

        return 0;
}


Measured memory_bytes: 17664