#include <bits/stdc++.h>
template <typename T>
struct xgcd_s {
  T m, n, gcd;
};
template <typename T>
xgcd_s<T> xgcd(T a, T b) {
  T m[] = {1, 0}, n[] = {0, 1}, q[] = {0, 0};
  for (int i = 0;; i ^= 1) {
    m[i] -= m[i ^ 1] * q[i];
    n[i] -= n[i ^ 1] * q[i];
    if (!b) return xgcd_s<T>{m[i], n[i], a};
    q[i] = a / b;
    a %= b;
    std::swap(a, b);
  }
}
template <unsigned M()>
struct _intmod {
 private:
  struct _p {
    unsigned x;
  };
  _intmod(_p x) { n = x.x; }

 public:
  unsigned n;
  _intmod() { n = 0; }
  _intmod(int x) { n = x < 0 ? M() + x % (int)M() : x % M(); }
  _intmod(unsigned x) { n = x % M(); }
  _intmod(long x) { n = unsigned(x < 0 ? M() + x % (long)M() : x % M()); }
  _intmod(unsigned long x) { n = x % M(); }
  _intmod(long long x) {
    n = unsigned(x < 0 ? M() + x % (long long)M() : x % M());
  }
  _intmod(unsigned long long x) { n = x % M(); }
  _intmod operator+(_intmod b) const { return {n + b.n}; }
  _intmod operator*(_intmod b) const {
    return {_p{unsigned((unsigned long long)n * b.n % M())}};
  }
  _intmod operator-(_intmod b) const {
    return {_p{n >= b.n ? n - b.n : M() + n - b.n}};
  }
  _intmod operator-() const { return {_p{n ? M() - n : 0U}}; }
  _intmod& operator+=(_intmod b) { return (*this = *this + b); }
  _intmod& operator-=(_intmod b) { return (*this = *this - b); }
  _intmod& operator/=(_intmod b) { return (*this = *this / b); }
  _intmod& operator*=(_intmod b) { return (*this = *this * b); }
  static _intmod mulinv(_intmod n) {
    xgcd_s<signed> x = xgcd<signed>(n.n, M());
    (void)0;
    return x.m;
  }
  _intmod operator/(_intmod b) const { return *this * mulinv(b); }
  bool operator==(_intmod b) const { return n == b.n; }
  bool operator!=(_intmod b) const { return n != b.n; }
  explicit operator int() const { return n; }
};
template <unsigned M()>
std::ostream& operator<<(std::ostream& o, _intmod<M> n) {
  return o << n.n;
}
template <unsigned M()>
std::istream& operator>>(std::istream& i, _intmod<M>& n) {
  long long x;
  i >> x;
  n = x;
  return i;
}
template <unsigned M>
unsigned intmod_unsignedconst() {
  static_assert(M > 0 && M < (1U << 31), "modulus bad");
  return M;
}
template <unsigned* M>
unsigned intmod_unsignedptr() {
  return *M;
}
template <unsigned M>
using intmod = _intmod<intmod_unsignedconst<M> >;
template <unsigned* M>
using intmodv = _intmod<intmod_unsignedptr<M> >;
static_assert(std::is_trivially_copyable<intmod<3> >::value, "");
using namespace std;
using I = intmod<998244353>;
I topGroupSizeP[2001][2001];
I favoritePow[2001];
I upsetPow[2001];
I expGames[2001];
I rrGames[2001];
int main() {
  int n, a, b;
  cin >> n >> a >> b;
  I favoriteP = I(a) / b;
  I upsetP = I(1) - favoriteP;
  favoritePow[0] = upsetPow[0] = 1;
  for (int i = 1; i <= n; i++) favoritePow[i] = favoriteP * favoritePow[i - 1];
  for (int i = 1; i <= n; i++) upsetPow[i] = upsetP * upsetPow[i - 1];
  for (int i = 1; i <= n; i++) rrGames[i] = i * (i - 1) / 2;
  for (int m = 1; m <= n; m++) {
    I notAllTiedP = 0;
    for (int tgSize = 1; tgSize < m; tgSize++) {
      I tgSizeP = topGroupSizeP[m - 1][tgSize] * favoritePow[tgSize];
      I superiorGroupExcludingLastP;
      if (tgSize == 1)
        superiorGroupExcludingLastP = 1;
      else if (tgSize == 3)
        superiorGroupExcludingLastP =
            topGroupSizeP[m - 1][1] * topGroupSizeP[m - 2][1];
      else
        superiorGroupExcludingLastP = topGroupSizeP[m - 1][tgSize - 1] /
                                      topGroupSizeP[tgSize - 1][tgSize - 1];
      tgSizeP += superiorGroupExcludingLastP * topGroupSizeP[tgSize][tgSize] *
                 upsetPow[m - tgSize];
      notAllTiedP += tgSizeP;
      topGroupSizeP[m][tgSize] = tgSizeP;
    }
    topGroupSizeP[m][m] = I(1) - notAllTiedP;
  }
  expGames[1] = 0;
  for (int m = 2; m <= n; m++) {
    I costExcludingAllTied = 0;
    for (int tgSize = 1; tgSize < m; tgSize++)
      costExcludingAllTied +=
          topGroupSizeP[m][tgSize] *
          (expGames[tgSize] + expGames[m - tgSize] - rrGames[m - tgSize]);
    I allTiedP = topGroupSizeP[m][m];
    costExcludingAllTied /= I(1) - allTiedP;
    I allTiedCost = rrGames[m] / (I(1) - allTiedP);
    expGames[m] = costExcludingAllTied + allTiedCost;
  }
  cout << expGames[n];
  return 0;
}
