func_code_string: #include <bits/stdc++.h>   template <typename T>   void MACRO_VAR_Scan(T& t) {     std::cin >> t;   }   template <typename First, typename... Rest>   void MACRO_VAR_Scan(First& first, Rest&... rest) {     std::cin >> first;     MACRO_VAR_Scan(rest...);   }   template <typename T>   void MACRO_VEC_ROW_Init(int n, T& t) {     t.resize(n);   }   template <typename First, typename... Rest>   void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {     first.resize(n);     MACRO_VEC_ROW_Init(n, rest...);   }   template <typename T>   void MACRO_VEC_ROW_Scan(int p, T& t) {     std::cin >> t[p];   }   template <typename First, typename... Rest>   void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {     std::cin >> first[p];     MACRO_VEC_ROW_Scan(p, rest...);   }   template <class T>   inline T CHMAX(T& a, const T b) {     return a = (a < b) ? b : a;   }   template <class T>   inline T CHMIN(T& a, const T b) {     return a = (a > b) ? b : a;   }   void CHECKTIME(std::function<void()> f) {     auto start = std::chrono::system_clock::now();     f();     auto end = std::chrono::system_clock::now();     auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start))                    .count();     std::cerr << res / (1.0e9) <<  s n ;   }   template <class T>   using V = std::vector<T>;   template <class T>   using VV = V<V<T>>;   template <typename S, typename T>   std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {     os <<  (  << p.first <<  ,   << p.second <<  ) ;     return os;   }   using ll = long long;   using ull = unsigned long long;   using ld = long double;   using PAIR = std::pair<ll, ll>;   using PAIRLL = std::pair<ll, ll>;   constexpr ll INFINT = (1 << 30) - 1;   constexpr ll INFINT_LIM = (1LL << 31) - 1;   constexpr ll INFLL = 1LL << 60;   constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);   constexpr double EPS = 1e-10;   constexpr ll MOD = 998244353;   constexpr double PI = 3.141592653589793238462643383279;   template <class T, size_t N>   void FILL(T (&a)[N], const T& val) {     for (auto& x : a) x = val;   }   template <class ARY, size_t N, size_t M, class T>   void FILL(ARY (&a)[N][M], const T& val) {     for (auto& b : a) FILL(b, val);   }   template <class T>   void FILL(std::vector<T>& a, const T& val) {     for (auto& x : a) x = val;   }   template <class ARY, class T>   void FILL(std::vector<std::vector<ARY>>& a, const T& val) {     for (auto& b : a) FILL(b, val);   }   class ModInt {     static constexpr std::int_fast64_t M = MOD;     using value_type = std::int_fast64_t;       public:     value_type x;     ModInt() : x(0) {}     ModInt(value_type n) : x(n % M) {       if (x < 0) x += M;     }     const std::int_fast64_t& operator()() const { return x; }     ModInt operator+() const { return *this; }     ModInt operator-() const { return ModInt(-x); }     ModInt& operator++() { return *this += 1; }     ModInt& operator++(signed tmp) { return *this += 1; }     ModInt& operator--() { return *this -= 1; }     ModInt& operator--(signed tmp) { return *this -= 1; }     ModInt& operator=(const ModInt& r) {       x = r.x;       return *this;     }     ModInt& operator=(const value_type& r) { return *this = ModInt(r); }     ModInt& operator+=(const ModInt& r) {       x += r.x;       if (x >= M) x -= M;       return *this;     }     ModInt& operator-=(const ModInt& r) {       x -= r.x;       if (x < +0) x += M;       return *this;     }     ModInt& operator*=(const ModInt& r) {       x = x * r.x % M;       return *this;     }     ModInt& operator/=(ModInt r) { return *this *= r ^= M - 2; }     ModInt& operator^=(value_type p) {       p %= M - 1;       if (p < 0) p += M - 1;       ModInt res(1);       while (p) {         if (p & 1) res *= *this;         *this *= *this;         p >>= 1;       }       return *this = res;     }     ModInt& operator+=(const value_type& r) { return *this += ModInt(r); }     ModInt& operator-=(const value_type& r) { return *this -= ModInt(r); }     ModInt& operator*=(const value_type& r) { return *this *= ModInt(r); }     ModInt& operator/=(const value_type& r) { return *this /= ModInt(r); }     ModInt operator+(const ModInt& r) const { return ModInt(*this) += r; }     ModInt operator-(const ModInt& r) const { return ModInt(*this) -= r; }     ModInt operator*(const ModInt& r) const { return ModInt(*this) *= r; }     ModInt operator/(const ModInt& r) const { return ModInt(*this) /= r; }     ModInt operator+(const value_type& r) const { return ModInt(*this) += r; }     ModInt operator-(const value_type& r) const { return ModInt(*this) -= r; }     ModInt operator*(const value_type& r) const { return ModInt(*this) *= r; }     ModInt operator/(const value_type& r) const { return ModInt(*this) /= r; }     ModInt operator^(const value_type& r) const { return ModInt(*this) ^= r; }   };   std::ostream& operator<<(std::ostream& os, const ModInt& obj) {     return os << obj.x;   }   std::istream& operator>>(std::istream& is, ModInt& obj) {     std::int_fast64_t x;     is >> x;     obj = ModInt(x);     return is;   }   struct S {     ModInt w, s0, s1;     bool operator<(const S& r) const {       return std::tie(w(), s0(), s1()) < std::tie(r.w(), r.s0(), r.s1());     }   };   std::map<S, ModInt> dp[2];   signed main() {     std::ios::sync_with_stdio(false);     std::cin.tie(0);     ;     ll n, m;     MACRO_VAR_Scan(n, m);     ;     std::vector<ll> a(n);     for (auto& i : a) std::cin >> i;     ;     std::vector<ModInt> w(n);     for (auto& i : w) std::cin >> i;     ;     ModInt bsum0 = 0, bsum1 = 0;     for (ll i = 0; i < ll(n); ++i) {       if (a[i])         bsum1 += w[i];       else         bsum0 += w[i];     }     for (ll i = 0; i < ll(n); ++i) {       dp[0].clear();       dp[1].clear();       dp[1][S{w[i], bsum0, bsum1}] = 1;       for (ll _ = 0; _ < ll(m); ++_) {         std::swap(dp[0], dp[1]);         for (const auto& p : dp[0]) {           const auto& s = p.first;           const auto& v = p.second;           auto sum = s.s0 + s.s1;           if (a[i]) {             dp[1][S{s.w + 1, s.s0 - 0, s.s1 + 1}] += v * s.w / sum;             dp[1][S{s.w + 0, s.s0 - 0, s.s1 + 1}] += v * (s.s1 - s.w) / sum;             dp[1][S{s.w + 0, s.s0 - 1, s.s1 + 0}] += v * s.s0 / sum;           } else {             dp[1][S{s.w - 1, s.s0 - 1, s.s1 + 0}] += v * s.w / sum;             dp[1][S{s.w + 0, s.s0 - 1, s.s1 + 0}] += v * (s.s0 - s.w) / sum;             dp[1][S{s.w + 0, s.s0 - 0, s.s1 + 1}] += v * s.s1 / sum;           }         }         dp[0].clear();       }       ModInt ans = 0;       for (const auto& p : dp[1]) ans += p.second * p.first.w;       std::cout << (ans);       std::cout <<   n ;       ;     }     return 0;   }   