func_code_string: #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;   }   