#ifdef _DEBUG
#include "MyLib.h"
#else
#define main_C main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i,s,e) for (int i = int(s); i < int(e); ++i)
#define REP(i,e) FOR(i,0,e)
//#define INF (INT_MAX/2)
#define EPS (1.0e-8)
//#define LINF (LLONG_MAX/2)
const int MGN = 8;
const int ARY_SZ_MAX = 10000000;
using namespace std;
using ll = long long; using ull = unsigned long long;
using vi = vector<int>; using vvi = vector<vi>; using vvvi = vector<vvi>;
using vb = vector<bool>; using vvb = vector<vb>; using vvvb = vector<vvb>;
using vl = vector<ll>; using vvl = vector<vl>;
using vd = vector<double>; using vs = vector<string>;
using pii = pair<int, int>; using pll = pair<ll, ll>;
using psi = pair<string, int>;
// functions
template<ll MOD>
struct ModLL {
    ll val;
    ModLL() :val(0) {}
    ModLL(ll v) : val(v >= 0 ? v % MOD : (MOD - (-v) % MOD) % MOD) {}

    ModLL operator -() const { return ModLL(-val); }

    ModLL& operator +=(const ModLL& r) {
        val += r.val;
        if (val >= MOD) val -= MOD;
        return (*this);
    }
    ModLL operator +(const ModLL& r) const {
        return ModLL(*this) += r;
    }

    ModLL& operator -=(const ModLL& r) {
        val += MOD - r.val;
        if (val >= MOD) val -= MOD;
        return (*this);
    }
    ModLL operator -(const ModLL& r) const {
        return ModLL(*this) -= r;
    }

    ModLL& operator *=(const ModLL& r) {
        val *= r.val;
        if (val >= MOD) val %= MOD;
        return (*this);
    }
    ModLL operator *(const ModLL& r) const {
        return ModLL(*this) *= r;
    }

    ModLL& operator /=(const ModLL& r) {
        (*this) *= r.inv();
        return (*this);
    }
    ModLL operator /(const ModLL& r) const {
        return ModLL(*this) /= r;
    }

    bool operator ==(const ModLL& r) {
        return val == r.val;
    }
    bool operator !=(const ModLL& r) {
        return val != r.val;
    }

    ModLL pow(ll n) const {
        ll tmp = val;
        ll ret = 1;
        while (n > 0) {
            if (n & 0x01) {
                ret *= tmp;
                ret %= MOD;
            }
            tmp = tmp * tmp;
            tmp %= MOD;
            n >>= 1LL;
        }
        return ModLL(ret);
    }

    ModLL inv() const {
        ll a = val, b = MOD, u = 1, v = 0;
        while (b > 0) {
            ll t = a / b;
            a -= t * b; swap(a, b);
            u -= t * v; swap(u, v);
        }
        return ModLL(u);
    }

    friend istream& operator >>(istream &is, ModLL<MOD> &r) {
        ll t; is >> t;
        r = ModLL<MOD>(t);
        return is;
    }
    friend ostream& operator <<(ostream &os, const ModLL<MOD> &r) {
        return os << r.val;
    }
};

struct ModCombination {
    const int Size;
    const ll MOD;
    vl fact;
    vl inv_fact;

    ll pow(ll a, ll n) {
        ll res = 1;
        while (n > 0) {
            if (n & 0x01) { 
                res *= a;
                res %= MOD;
            }
            a = a*a;
            a %= MOD;
            n >>= 1;
        }
        return res;
    }

    ll inv(ll num) {
        return pow(num, MOD - 2);
    }

    ModCombination(const int SIZE, const int MOD) 
        : Size(SIZE), MOD(MOD) {
        fact = vl(Size);
        fact[0] = 1;
        FOR (i,1,Size) {
            fact[i] = fact[i - 1] * i % MOD;
        }

        inv_fact = vl(Size);
        inv_fact[0] = 1;
        inv_fact[Size-1] = inv(fact[Size-1]);
        for (int i = Size - 1; i > 0; i--) {
            inv_fact[i - 1] = inv_fact[i] * i % MOD;
        }
    }

    int C(int n, int r) {
        if (n < 0 || r < 0 || n < r) return 0;
        return fact[n] * inv_fact[r] % MOD * inv_fact[n - r] % MOD;
    }

    int P(int n, int r) {
        if (n < 0 || r < 0 || n < r) return 0;
        return fact[n] * inv_fact[n - r] % MOD;
    }
};
#endif

const ll MOD = (ll)1e9 + 7;
using mll = ModLL<MOD>;

int main_C() {
    std::cin.tie(0);
    ios::sync_with_stdio(false);

    ll N, A, B, C; std::cin >> N >> A >> B >> C;

    ModCombination comb(2 * N, MOD);

    mll pt = mll(A) / mll(A+B);
    mll pa = mll(B) / mll(A+B);

    mll ans = mll(0);
    FOR(i,N,2*N) {
        // Σ M-1CN-1 {pt^N pa^(M-N) + pt^(M-N) pa^N} 100M/(A+B)
        mll t = mll(1);
        mll cmb = comb.C(i - 1, N - 1);
        mll pow = (pt.pow(N)*pa.pow(i-N) + pt.pow(i-N)*pa.pow(N));
        t *= cmb;
        t *= pow;
        t *= mll(100);
        t *= mll(i);
        t /= mll(A + B);
        ans += t;
    }

    cout << ans << endl;

    return 0;
}

Measured memory_bytes: 3328