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: # -*- coding: utf-8 -*-
  
  import sys
  
  
  def input():
      return sys.stdin.readline().strip()
  
  
  def list2d(a, b, c):
      return [[c] * b for i in range(a)]
  
  
  def list3d(a, b, c, d):
      return [[[d] * c for j in range(b)] for i in range(a)]
  
  
  def ceil(x, y=1):
      return int(-(-x // y))
  
  
  def INT():
      return int(input())
  
  
  def MAP():
      return map(int, input().split())
  
  
  def LIST():
      return list(map(int, input().split()))
  
  
  def Yes():
      print("Yes")
  
  
  def No():
      print("No")
  
  
  def YES():
      print("YES")
  
  
  def NO():
      print("NO")
  
  
  sys.setrecursionlimit(10**9)
  INF = float("inf")
  MOD = 10**9 + 7
  
  
  def init_fact_inv(MAX: int, MOD: int) -> list:
      """
      階乗たくさん使う時用のテーブル準備
      MAX：階乗に使う数値の最大以上まで作る
      """
      # 階乗テーブル
      factorial = [1] * MAX
      factorial[0] = factorial[1] = 1
      for i in range(2, MAX):
          factorial[i] = factorial[i - 1] * i % MOD
      # 階乗の逆元テーブル
      inverse = [1] * MAX
      # powに第三引数入れると冪乗のmod付計算を高速にやってくれる
      inverse[MAX - 1] = pow(factorial[MAX - 1], MOD - 2, MOD)
      for i in range(MAX - 2, 0, -1):
          # 最後から戻っていくこのループならMAX回powするより処理が速い
          inverse[i] = inverse[i + 1] * (i + 1) % MOD
      return factorial, inverse
  
  
  # 組み合わせの数(必要な階乗と逆元のテーブルを事前に作っておく)
  def nCr(n, r, factorial, inverse):
      if n < r:
          return 0
      # 10C7 = 10C3
      r = min(r, n - r)
      # 分子の計算
      numerator = factorial[n]
      # 分母の計算
      denominator = inverse[r] * inverse[n - r] % MOD
      return numerator * denominator % MOD
  
  
  def fermat(x, y, MOD):
      return x * pow(y, MOD - 2, MOD) % MOD
  
  
  N, A, B, C = MAP()
  
  fact, inv = init_fact_inv(N * 2 + 1, MOD)
  
  # MODの割り算
  AAB = fermat(A, A + B, MOD)
  BAB = fermat(B, A + B, MOD)
  
  ans = 0
  for m in range(N, N * 2):
      # (引き分けを考えずに)m回で終わる確率
      x = (
          pow(AAB, N, MOD) * pow(BAB, m - N, MOD)
          + pow(BAB, N, MOD) * pow(AAB, m - N, MOD)
      ) * nCr(m - 1, N - 1, fact, inv)
      # 引き分け以外の試合がm回行われるまでの試合数の期待値
      y = fermat(m * 100, A + B, MOD)
      ans = (ans + x * y) % 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"}]