#Combinationクラス

class Combination:

    '''

    計算量：階乗・逆元テーブルの作成O(N)

            nCkを求めるO(1)

    '''



    def __init__(self, n, MOD):

        self.fact = [1]

        for i in range(1, n + 1):

            self.fact.append(self.fact[-1] * i % MOD)

        self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]

        self.MOD = MOD



    def factorial(self, k):

        '''k!を求める'''

        return self.fact[k]



    def inverse_factorial(self, k):

        '''k!の逆元を求める'''

        return self.inv_fact[k]



    def combination(self, k, r):

        '''kCrを求める'''

        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD







from fractions import Fraction





MOD = 10**9 + 7

n, a, b, c = list(map(int, input().split()))



#n-1から2n-2まで

comb = Combination(2*n, MOD)

mod_li = [1]

for i in range(1, 2*n + 1):

    mod_li.append(mod_li[-1] * (a+b) % MOD)

p1 = [1]

p2 = [1]

for i in range(1, n+1):

    p1.append((p1[-1] * a) % MOD)

    p2.append((p2[-1] * b) % MOD)

q = mod_li[2*n-1]

p = 0





for i in range(n):

    tmp_bunshi = (n+i) * (mod_li[n-i-1]) * p1[n] * p2[i] * comb.combination(n-1+i,i)

    tmp_bunshi += (n+i) * (mod_li[n-i-1]) * p2[n] * p1[i] * comb.combination(n-1+i,i)

    p += tmp_bunshi

    p %= MOD

p *= 100

q *= (a+b)

ans = Fraction(p, q)

p = ans.numerator

q = ans.denominator

print(((pow(q, MOD-2, MOD) * p) % MOD))
class Combination:

    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""

    def __init__(self, n, MOD):

        self.fact = [1]

        for i in range(1, n + 1):

            self.fact.append(self.fact[-1] * i % MOD)

        self.inv_fact = [0] * (n + 1)

        self.inv_fact[n] = pow(self.fact[n], MOD - 2, MOD)

        for i in reversed(list(range(n))):

            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % MOD

        self.MOD = MOD



    def factorial(self, k):

        """k!を求める O(1)"""

        return self.fact[k]



    def inverse_factorial(self, k):

        """k!の逆元を求める O(1)"""

        return self.inv_fact[k]



    def permutation(self, k, r):

        """kPrを求める O(1)"""

        if k < r:

            return 0

        return (self.fact[k] * self.inv_fact[k - r]) % self.MOD



    def combination(self, k, r):

        """kCrを求める O(1)"""

        if k < r:

            return 0

        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD





n, a, b, c = list(map(int, input().split()))

MOD = 10 ** 9 + 7

comb = Combination(10 ** 6, MOD)



pa = a * pow(a + b, MOD - 2, MOD) % MOD

pb = b * pow(a + b, MOD - 2, MOD) % MOD



ec = 100 * pow(100 - c, MOD - 2, MOD) % MOD



ans1 = 0

tmp = pow(pa, n, MOD)

for i in range(n):

    ans1 += tmp * pow(pb, i, MOD) * comb.combination(n - 1 + i, i) * (n + i) * ec

    ans1 %= MOD



ans2 = 0

tmp = pow(pb, n, MOD)

for i in range(n):

    ans2 += tmp * pow(pa, i, MOD) * comb.combination(n - 1 + i, i) * (n + i) * ec

    ans2 %= MOD



print(((ans1 + ans2) % MOD))
# Combinationクラス
class Combination:
    """
    計算量：階乗・逆元テーブルの作成O(N)
            nCkを求めるO(1)
    """

    def __init__(self, n, MOD):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % MOD)
        self.inv_fact = [pow(self.fact[i], MOD - 2, MOD) for i in range(n + 1)]
        self.MOD = MOD

    def factorial(self, k):
        """k!を求める"""
        return self.fact[k]

    def inverse_factorial(self, k):
        """k!の逆元を求める"""
        return self.inv_fact[k]

    def combination(self, k, r):
        """kCrを求める"""
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD


from fractions import Fraction

MOD = 10**9 + 7
n, a, b, c = list(map(int, input().split()))
# n-1から2n-2まで
comb = Combination(2 * n, MOD)
mod_li = [1]
for i in range(1, 2 * n + 1):
    mod_li.append(mod_li[-1] * (a + b) % MOD)
p1 = [1]
p2 = [1]
for i in range(1, n + 1):
    p1.append((p1[-1] * a) % MOD)
    p2.append((p2[-1] * b) % MOD)
q = mod_li[2 * n - 1]
p = 0
for i in range(n):
    tmp_bunshi = (
        (n + i) * (mod_li[n - i - 1]) * p1[n] * p2[i] * comb.combination(n - 1 + i, i)
    )
    tmp_bunshi += (
        (n + i) * (mod_li[n - i - 1]) * p2[n] * p1[i] * comb.combination(n - 1 + i, i)
    )
    p += tmp_bunshi
    p %= MOD
p *= 100
q *= a + b
ans = Fraction(p, q)
p = ans.numerator
q = ans.denominator
print(((pow(q, MOD - 2, MOD) * p) % MOD))

class Combination:
    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""

    def __init__(self, n, MOD):
        self.fact = [1]
        for i in range(1, n + 1):
            self.fact.append(self.fact[-1] * i % MOD)
        self.inv_fact = [0] * (n + 1)
        self.inv_fact[n] = pow(self.fact[n], MOD - 2, MOD)
        for i in reversed(list(range(n))):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % MOD
        self.MOD = MOD

    def factorial(self, k):
        """k!を求める O(1)"""
        return self.fact[k]

    def inverse_factorial(self, k):
        """k!の逆元を求める O(1)"""
        return self.inv_fact[k]

    def permutation(self, k, r):
        """kPrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r]) % self.MOD

    def combination(self, k, r):
        """kCrを求める O(1)"""
        if k < r:
            return 0
        return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD


n, a, b, c = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(10**6, MOD)
pa = a * pow(a + b, MOD - 2, MOD) % MOD
pb = b * pow(a + b, MOD - 2, MOD) % MOD
ec = 100 * pow(100 - c, MOD - 2, MOD) % MOD
ans1 = 0
tmp = pow(pa, n, MOD)
for i in range(n):
    ans1 += tmp * pow(pb, i, MOD) * comb.combination(n - 1 + i, i) * (n + i) * ec
    ans1 %= MOD
ans2 = 0
tmp = pow(pb, n, MOD)
for i in range(n):
    ans2 += tmp * pow(pa, i, MOD) * comb.combination(n - 1 + i, i) * (n + i) * ec
    ans2 %= MOD
print(((ans1 + ans2) % MOD))

-# Combinationクラス -    """ -    計算量：階乗・逆元テーブルの作成O(N) -            nCkを求めるO(1) -    """ +    """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う""" -        self.inv_fact = [pow(self.fact[i], MOD - 2, MOD) for i in range(n + 1)] +        self.inv_fact = [0] * (n + 1) +        self.inv_fact[n] = pow(self.fact[n], MOD - 2, MOD) +        for i in reversed(list(range(n))): +            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % MOD -        """k!を求める""" +        """k!を求める O(1)""" -        """k!の逆元を求める""" +        """k!の逆元を求める O(1)""" +    def permutation(self, k, r): +        """kPrを求める O(1)""" +        if k < r: +            return 0 +        return (self.fact[k] * self.inv_fact[k - r]) % self.MOD + -        """kCrを求める""" +        """kCrを求める O(1)""" +        if k < r: +            return 0 -from fractions import Fraction - +n, a, b, c = list(map(int, input().split())) -n, a, b, c = list(map(int, input().split())) -# n-1から2n-2まで -comb = Combination(2 * n, MOD) -mod_li = [1] -for i in range(1, 2 * n + 1): -    mod_li.append(mod_li[-1] * (a + b) % MOD) -p1 = [1] -p2 = [1] -for i in range(1, n + 1): -    p1.append((p1[-1] * a) % MOD) -    p2.append((p2[-1] * b) % MOD) -q = mod_li[2 * n - 1] -p = 0 +comb = Combination(10**6, MOD) +pa = a * pow(a + b, MOD - 2, MOD) % MOD +pb = b * pow(a + b, MOD - 2, MOD) % MOD +ec = 100 * pow(100 - c, MOD - 2, MOD) % MOD +ans1 = 0 +tmp = pow(pa, n, MOD) -    tmp_bunshi = ( -        (n + i) * (mod_li[n - i - 1]) * p1[n] * p2[i] * comb.combination(n - 1 + i, i) -    ) -    tmp_bunshi += ( -        (n + i) * (mod_li[n - i - 1]) * p2[n] * p1[i] * comb.combination(n - 1 + i, i) -    ) -    p += tmp_bunshi -    p %= MOD -p *= 100 -q *= a + b -ans = Fraction(p, q) -p = ans.numerator -q = ans.denominator -print(((pow(q, MOD - 2, MOD) * p) % MOD)) +    ans1 += tmp * pow(pb, i, MOD) * comb.combination(n - 1 + i, i) * (n + i) * ec +    ans1 %= MOD +ans2 = 0 +tmp = pow(pb, n, MOD) +for i in range(n): +    ans2 += tmp * pow(pa, i, MOD) * comb.combination(n - 1 + i, i) * (n + i) * ec +    ans2 %= MOD +print(((ans1 + ans2) % MOD))