output_description: Print the expected number of games that will be played, in the manner
  specified in the statement.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N A B C
attempt: class Combinatorics:
      def __init__(self, N, mod):
          """
          Preprocess for calculating binomial coefficients nCr (0 <= r <= n, 0 <= n <= N)
          over the finite field Z/(mod)Z.
          Input:
              N (int): maximum n
              mod (int): a prime number. The order of the field Z/(mod)Z over which nCr is calculated.
          """
          self.mod = mod
          self.fact = {i: None for i in range(N + 1)}  # n!
          self.inverse = {
              i: None for i in range(1, N + 1)
          }  # inverse of n in the field Z/(MOD)Z
          self.fact_inverse = {
              i: None for i in range(N + 1)
          }  # inverse of n! in the field Z/(MOD)Z
  
          # preprocess
          self.fact[0] = self.fact[1] = 1
          self.fact_inverse[0] = self.fact_inverse[1] = 1
          self.inverse[1] = 1
          for i in range(2, N + 1):
              self.fact[i] = i * self.fact[i - 1] % self.mod
              q, r = divmod(self.mod, i)
              self.inverse[i] = (-(q % self.mod) * self.inverse[r]) % self.mod
              self.fact_inverse[i] = self.inverse[i] * self.fact_inverse[i - 1] % self.mod
  
      def perm(self, n, r):
          """
          Calculate nPr = n! / (n-r)! % mod
          """
          if n < r or n < 0 or r < 0:
              return 0
          else:
              return (self.fact[n] * self.fact_inverse[n - r]) % self.mod
  
      def binom(self, n, r):
          """
          Calculate nCr = n! /(r! (n-r)!) % mod
          """
          if n < r or n < 0 or r < 0:
              return 0
          else:
              return (
                  self.fact[n]
                  * (self.fact_inverse[r] * self.fact_inverse[n - r] % self.mod)
                  % self.mod
              )
  
      def hom(self, n, r):
          """
          Calculate nHr = {n+r-1}Cr % mod.
          Assign r objects to one of n classes.
          Arrangement of r circles and n-1 partitions:
              o o o | o o | | | o | | | o o | | o
          """
          if n == 0 and r > 0:
              return 0
          if n >= 0 and r == 0:
              return 1
          return self.binom(n + r - 1, r)
  
  
  def extended_euclid(a, b):
      x1, y1, m = 1, 0, a
      x2, y2, n = 0, 1, b
      while m % n != 0:
          q, r = divmod(m, n)
          x1, y1, m, x2, y2, n = x2, y2, n, x1 - q * x2, y1 - q * y2, r
      return (x2, y2, n)
  
  
  def modular_inverse(a, mod):
      x, _, g = extended_euclid(a, mod)
      if g != 1:
          return None  # Modular inverse of a does not exist
      else:
          return x % mod
  
  
  N, A, B, C = map(int, input().split())
  MOD = 10**9 + 7
  com = Combinatorics(2 * N, MOD)
  pa = A * modular_inverse(A + B, MOD)
  pb = B * modular_inverse(A + B, MOD)
  n_first_AB = (100 * modular_inverse(100 - C, MOD)) % MOD
  ans = 0
  for m in range(N, 2 * N):  # E[X] = E_M[ E[X | M] ]
      Exp_X_given_M = (m * n_first_AB) % MOD
      prob_m = (
          com.binom(m - 1, N - 1)
          * (
              (pow(pa, N, MOD) * pow(pb, m - N, MOD)) % MOD
              + (pow(pa, m - N, MOD) * pow(pb, N, MOD)) % MOD
          )
          % MOD
      )
      ans = (ans + Exp_X_given_M * prob_m) % MOD
  print(ans)
  
problem_description: Statement
  
  Takahashi and Aoki will play a game. They will repeatedly play it until one of
  them have N wins in total.
  
  When they play the game once, Takahashi wins with probability A %, Aoki wins
  with probability B %, and the game ends in a draw (that is, nobody wins) with
  probability C %. Find the expected number of games that will be played, and
  print it as follows.
  
  We can represent the expected value as P/Q with coprime integers P and Q.
  Print the integer R between 0 and 10^9+6 (inclusive) such that R \times Q
  \equiv P\pmod {10^9+7}. (Such an integer R always uniquely exists under the
  constraints of this problem.)
samples: [{"input": "1 25 25 50", "output": "2\n    \n\nSince N=1, they will repeat the game until one of them wins. The expected\nnumber of games played is 2.\n\n* * *"}, {"input": "4 50 50 0", "output": "312500008\n    \n\nC may be 0.\n\n* * *"}, {"input": "1 100 0 0", "output": "1\n    \n\nB may also be 0.\n\n* * *"}, {"input": "100000 31 41 28", "output": "104136146"}]