#include <iostream>
#include <vector>
#include <array>
#include <deque>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <numeric>
#include <utility>
#include <cmath>
#include <iomanip>

using namespace std;
using ll=long long int;

template <typename T>
T powi(T a, ll n) {
    T ret = 1;
    while (n > 0) {
        if (n & 1) ret *= a; 
        a *= a;
        n >>= 1;
    }
    return ret;
}

template <ll mod>
class ModInt {
private:
    ll num;
public:
    ModInt() {};
    ModInt(ll n) { num = n % mod; }
    ModInt inv() const { return powi(*this, mod-2); }
    explicit operator ll() const { return num; }

    ModInt& operator+=(const ModInt& a) {
        num += a.num; 
        if (num >= mod) num -= mod; 
        return *this;
    }
    ModInt& operator-=(const ModInt& a) {
        if (num < a.num) num += mod;
        num -= a.num;
        return *this;
    }
    ModInt& operator*=(const ModInt& a) {
        num = num * a.num % mod;
        return *this;
    }
    ModInt& operator/=(const ModInt& a) { return *this *= a.inv(); }
    friend ModInt operator+(const ModInt& a, const ModInt& b) { return ModInt(a) += b; }
    friend ModInt operator-(const ModInt& a, const ModInt& b) { return ModInt(a) -= b; }
    friend ModInt operator*(const ModInt& a, const ModInt& b) { return ModInt(a) *= b; }
    friend ModInt operator/(const ModInt& a, const ModInt& b) { return ModInt(a) /= b; }

    friend ostream& operator<<(ostream& os, const ModInt& a) { return os << a.num; }
    friend istream& operator>>(istream& is, ModInt& a) {
        ll tmp;
        is >> tmp;
        a.num = tmp % mod;
        return is;
    }

    class Factorial {
    private:
        static vector<ModInt> table[2];
    public:
        static void reserve(int n) {
            for (auto &v: table) v.resize(n+1);
            table[0][0] = 1;
            for (int i = 1; i <= n; ++i) table[0][i] = table[0][i-1].num * i;
            table[1][n] = table[0][n].inv();
            for (int i = n; i >= 1; --i) table[1][i-1] = table[1][i].num * i;
        }
    
    private:
        int num;
    public:
        Factorial() {};
        Factorial(int n): num(n) {};
        ModInt finv() const { return table[1][num]; }
        operator ModInt() const { return table[0][num]; }
    };
    ModInt& operator /=(const Factorial& a) { return *this *= a.finv(); }
    friend ModInt operator /(const ModInt& a, const Factorial& b) { return ModInt(a) /= b; }
};
template<ll mod>
vector<ModInt<mod>> ModInt<mod>::Factorial::table[2];

using mint = ModInt<1000000007>;
using fact = mint::Factorial;

mint P(int n, int k) {
    return fact(n) / fact(n-k);
}
mint C(int n, int k) {
    return fact(n) / fact(n-k) / fact(k);
}
mint H(int n, int k) {
    return C(n+k-1, k);
}

int main() {
    int n;
    cin >> n;
    mint a, b, c;
    cin >> a >> b >> c;

    fact::reserve(2*n-1);
    mint m = 0;
    for (int i = n; i <= 2*n-1; ++i) {
        mint t = C(i-1, i-n) * powi(a, i-n) * powi(b, n);
        t += C(i-1, i-n) * powi(b, i-n) * powi(a, n);
        t /= powi(a+b, i);
        t *= i;
        m += t;
    }
    m *= 100 / (a+b);

    cout << m << endl;

    return 0;
}


Measured memory_bytes: 3328