#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 2005;
const int M = N * N;
int h[N][N], f[N], s[N];
int p, ip, o, io, pw[M], ipw[M], ow[M], iow[M];
int inverse(int n) {
  if (n >= mod) return inverse(n % mod);
  if (n == 1) return 1;
  return (mod - mod / n) * 1LL * inverse(mod % n) % mod;
}
inline int modPow(int a, int b) {
  int ret = 1;
  while (b) {
    if (b & 1) ret = ret * 1LL * a % mod;
    a = a * 1LL * a % mod;
    b >>= 1;
  }
  return ret;
}
inline int get(int n, int k) {
  return iow[k * (k + 1) / 2] * 1LL * pw[n * k - k * (k - 1) / 2] % mod;
}
void init() {
  memset(h, 0, sizeof(h));
  memset(f, 0, sizeof(s));
  memset(s, 0, sizeof(s));
  pw[0] = ipw[0] = ow[0] = iow[0] = 1;
  for (int i = 1; i < M; i++) {
    pw[i] = pw[i - 1] * 1LL * p % mod;
    ow[i] = ow[i - 1] * 1LL * o % mod;
    ipw[i] = ipw[i - 1] * 1LL * ip % mod;
    iow[i] = iow[i - 1] * 1LL * io % mod;
  }
  h[0][0] = 1;
  int prod = 1;
  for (int n = 1; n < N; n++) {
    h[n][0] = 1;
    prod = prod * 1LL * (mod + 1 - p) % mod;
    prod = prod * 1LL * ip % mod;
    for (int k = 1; k <= n; k++) {
      h[n][k] = (h[n - 1][k] + prod * 1LL * h[n - 1][k - 1]) % mod;
    }
  }
  for (int n = 1; n < N; n++) {
    for (int k = 1; k <= n; k++) {
      h[n][k] = h[n][k] * 1LL * get(n, k) % mod;
    }
  }
  s[1] = 1;
  for (int n = 2; n < N; n++) {
    s[n] = 1;
    for (int k = 1; k < n; k++) {
      s[n] -= s[k] * 1LL * h[n][k] % mod;
      if (s[n] < 0) s[n] += mod;
    }
    for (int k = 1; k <= n; k++) {
      h[n][k] = h[n][k] * 1LL * s[k] % mod;
    }
  }
  f[1] = 0;
  for (int n = 2; n < N; n++) {
    long long tmp = n * (n - 1) / 2;
    for (int k = 1; k < n; k++) {
      tmp += h[n][k] * 1LL * (f[k] + f[n - k] - (n - k) * (n - k - 1) / 2);
      tmp %= mod;
    }
    (tmp *= inverse(mod + 1 - s[n])) %= mod;
    f[n] = tmp;
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int n;
  cin >> n;
  int a, b;
  cin >> a >> b;
  p = a * 1LL * inverse(b) % mod;
  ip = inverse(p);
  o = mod + 1 - p;
  if (o >= mod) o -= mod;
  io = inverse(o);
  init();
  cout << f[n] << endl;
  return 0;
}
