#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
using namespace std;
// using namespace __gnu_pbds;

// #pragma GCC optimize("O3,unroll-loops")
// #pragma GCC target("avx2")
#define watch(x) cout << (#x) << "=" << (x) << '\n'
#define mset(d, val) memset(d, val, sizeof(d))
#define setp(x) cout << fixed << setprecision(x)
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define forn(i, a, b) for (int i = (a); i < (b); i++)
#define fore(i, a, b) for (int i = (a); i <= (b); i++)
#define pb push_back
#define F first
#define S second
#define fbo find_by_order
#define ook order_of_key
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
// template<typename T>
// using pbds = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
void SD(int t = 0) { cout << "PASSED " << t << endl; }
ostream &operator<<(ostream &out, ii x)
{
    out << "(" << x.F << "," << x.S << ")";
    return out;
}
template <typename T>
void amax(T &a, T b) { a = max(a, b); }
template <typename T>
void amin(T &a, T b) { a = min(a, b); }
const ll INF = ll(1e18);
const int MOD = 1e9 + 7;

vector<ll> fact, ifact, inv, pow2;
ll add(ll a, ll b, ll m = MOD)
{
    a += b;
    if (abs(a) >= m)
        a %= m;
    if (a < 0)
        a += m;
    return a;
}
ll mult(ll a, ll b, ll m = MOD)
{
    if (abs(a) >= m)
        a %= m;
    if (abs(b) >= m)
        b %= m;
    a *= b;
    if (abs(a) >= m)
        a %= m;
    if (a < 0)
        a += m;
    return a;
}
void radd(ll &a, ll b, ll m = MOD) { a = add(a, b, m); }
void rmult(ll &a, ll b, ll m = MOD) { a = mult(a, b, m); }
ll pw(ll a, ll b, ll m = MOD)
{
    assert(b >= 0); // can return 0 if desired
    if (abs(a) >= m)
        a %= m;
    if (a == 0 && b == 0)
        return 0; // value of 0^0
    ll r = 1;
    while (b)
    {
        if (b & 1)
            r = mult(r, a, m);
        a = mult(a, a, m);
        b >>= 1;
    }
    return r;
}
ll inverse(ll a, ll m = MOD)
{
    return pw(a, m - 2);
}
ll choose(ll a, ll b)
{
    assert(min(a, b) >= 0);
    if (a < b)
        return 0;
    if (b == 0)
        return 1;
    if (a == b)
        return 1;
    return mult(fact[a], mult(ifact[b], ifact[a - b]));
}
void init(ll _n)
{
    fact.clear();
    ifact.clear();
    inv.clear();
    pow2.clear();
    fact.resize(_n + 1);
    ifact.resize(_n + 1);
    inv.resize(_n + 1);
    pow2.resize(_n + 1);
    pow2[0] = 1;
    ifact[0] = 1;
    fact[0] = 1;
    for (int i = 1; i <= _n; i++)
    {
        pow2[i] = add(pow2[i - 1], pow2[i - 1]);
        fact[i] = mult(fact[i - 1], i);
    }
    ifact[_n] = inverse(fact[_n]);
    for (int i = _n - 1; i >= 1; i--)
    {
        ifact[i] = mult(ifact[i + 1], i + 1);
    }
    for (int i = 1; i <= _n; i++)
    {
        inv[i] = mult(fact[i - 1], ifact[i]);
    }
}

const bool DEBUG = 0;
const int MAXN = 1000005;
const int LG = 21;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    ll n, G, I, E;
    cin >> n >> G >> I >> E;

    G = min(G, n * 2);
    E = min(E, n * 2 - G);
    I = min(I, n * 2 - G - E);
    init(n * 3);

    ll total_value = 0;
    ll total_ways = mult(choose(2 * n, G), fact[G]);
    for (ll gen_pair_count = max(0LL, G - n); gen_pair_count <= min(n, G / 2); gen_pair_count++)
    {
        vector<ll> seat_count(3, 0);
        seat_count[2] = gen_pair_count;
        seat_count[1] = G - gen_pair_count * 2;
        seat_count[0] = n - seat_count[2] - seat_count[1];

        ll cur_ways = mult(choose(n, seat_count[2]), choose(n - seat_count[2], seat_count[1]));
        rmult(cur_ways, fact[G]);
        rmult(cur_ways, pow2[seat_count[1]]);

        ll cur_value = G;

        // extroverts
        bool single_are_extro;
        if (E <= seat_count[1])
        {
            single_are_extro = false;
            radd(cur_value, E);
            seat_count[1] -= E;
            seat_count[2] += E;
        }
        else
        {
            single_are_extro = true;

            // seat happy extroverts
            radd(cur_value, seat_count[1]);
            ll rem_extro = E - seat_count[1]; // only happily-seatable extros
            seat_count[2] += seat_count[1];
            seat_count[1] = 0;

            // seat remaining extroverts, pairing them
            ll new_pair_count = min(seat_count[0], rem_extro / 2);
            radd(cur_value, 2 * new_pair_count);
            seat_count[2] += new_pair_count;
            seat_count[0] -= new_pair_count;
            if (rem_extro % 2 == 1)
            {
                seat_count[1]++;
                seat_count[0]--;
            }
        }

        // happy introverts
        ll happy_intro_count = min(I, seat_count[0]);
        radd(cur_value, happy_intro_count);
        seat_count[0] -= happy_intro_count;
        seat_count[1] += happy_intro_count;
        ll rem_intro = I - happy_intro_count;

        // remaining single seats are intro + extro or intro + gen
        ll intro_beside_non_intro = min(rem_intro, seat_count[1] - happy_intro_count);
        if (single_are_extro)
            radd(cur_value, intro_beside_non_intro);
        seat_count[1] -= intro_beside_non_intro;
        seat_count[2] += intro_beside_non_intro;
        rem_intro -= intro_beside_non_intro;

        // intros forced to seat beside intros
        radd(cur_value, -rem_intro);

        radd(total_value, mult(cur_ways, cur_value));
    }

    cout << mult(total_value, inverse(total_ways)) << '\n';

    return 0;
}