#include <bits/stdc++.h>
using namespace std;
namespace from_ecnerwala {
template <int MOD_>
struct modnum {
  static constexpr int MOD = MOD_;
  static_assert(MOD_ > 0, "MOD must be positive");

 private:
  using ll = long long;
  int v;
  static int minv(int a, int m) {
    a %= m;
    assert(a);
    return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
  }

 public:
  modnum() : v(0) {}
  modnum(ll v_) : v(int(v_ % MOD)) {
    if (v < 0) v += MOD;
  }
  explicit operator int() const { return v; }
  friend std::ostream& operator<<(std::ostream& out, const modnum& n) {
    return out << int(n);
  }
  friend std::istream& operator>>(std::istream& in, modnum& n) {
    ll v_;
    in >> v_;
    n = modnum(v_);
    return in;
  }
  friend bool operator==(const modnum& a, const modnum& b) {
    return a.v == b.v;
  }
  friend bool operator!=(const modnum& a, const modnum& b) {
    return a.v != b.v;
  }
  modnum inv() const {
    modnum res;
    res.v = minv(v, MOD);
    return res;
  }
  modnum neg() const {
    modnum res;
    res.v = v ? MOD - v : 0;
    return res;
  }
  modnum operator-() const { return neg(); }
  modnum operator+() const { return modnum(*this); }
  modnum& operator++() {
    v++;
    if (v == MOD) v = 0;
    return *this;
  }
  modnum& operator--() {
    if (v == 0) v = MOD;
    v--;
    return *this;
  }
  modnum& operator+=(const modnum& o) {
    v += o.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  modnum& operator-=(const modnum& o) {
    v -= o.v;
    if (v < 0) v += MOD;
    return *this;
  }
  modnum& operator*=(const modnum& o) {
    v = int(ll(v) * ll(o.v) % MOD);
    return *this;
  }
  modnum& operator/=(const modnum& o) { return *this *= o.inv(); }
  friend modnum operator++(modnum& a, int) {
    modnum r = a;
    ++a;
    return r;
  }
  friend modnum operator--(modnum& a, int) {
    modnum r = a;
    --a;
    return r;
  }
  friend modnum operator+(const modnum& a, const modnum& b) {
    return modnum(a) += b;
  }
  friend modnum operator-(const modnum& a, const modnum& b) {
    return modnum(a) -= b;
  }
  friend modnum operator*(const modnum& a, const modnum& b) {
    return modnum(a) *= b;
  }
  friend modnum operator/(const modnum& a, const modnum& b) {
    return modnum(a) /= b;
  }
};
using num = modnum<998244353>;
}  // namespace from_ecnerwala
using namespace from_ecnerwala;
const int MAXN = 55;
const int MAXW = 51;
const int MAXS = 100000;
int N, M;
int S;
int L[MAXN], W[MAXN];
num invs[MAXS];
void precomp() {
  for (int i = 1; i < MAXS; i++) {
    invs[i] = 1 / num(i);
  }
}
num dp[MAXW][MAXW][MAXW];
num ndp[MAXW][MAXW][MAXW];
num go(int like, int w, int slike, int sunlike) {
  memset(dp, 0, sizeof(dp));
  dp[0][0][0] = 1;
  for (int i = 0; i < M; i++) {
    memset(ndp, 0, sizeof(ndp));
    for (int a = 0; a < MAXW; a++) {
      for (int b = 0; b < MAXW; b++) {
        for (int c = 0; c < MAXW; c++) {
          if (dp[a][b][c] == 0) continue;
          int wsum = S + b - c + (like ? a : -a);
          num denom = invs[wsum];
          if (like) {
            ndp[a + 1][b][c] += dp[a][b][c] * num(w + a) * denom;
          } else {
            if (w > a) {
              ndp[a + 1][b][c] += dp[a][b][c] * num(w - a) * denom;
            }
          }
          ndp[a][b + 1][c] += dp[a][b][c] * num(slike + b) * denom;
          if (sunlike > c) {
            ndp[a][b][c + 1] += dp[a][b][c] * num(sunlike - c) * denom;
          }
        }
      }
    }
    memcpy(dp, ndp, sizeof(dp));
  }
  num ans = 0;
  for (int a = 0; a < MAXW; a++) {
    for (int b = 0; b < MAXW; b++) {
      for (int c = 0; c < MAXW; c++) {
        ans += num(w + (like ? a : -a)) * dp[a][b][c];
      }
    }
  }
  return ans;
}
mt19937 rng(114514);
int rand_int(int a, int b) { return uniform_int_distribution<int>(a, b)(rng); }
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  precomp();
  cin >> N >> M;
  for (int i = 0; i < N; i++) {
    cin >> L[i];
  }
  int s_like = 0;
  int s_unlike = 0;
  for (int i = 0; i < N; i++) {
    cin >> W[i];
    S += W[i];
    if (L[i]) {
      s_like += W[i];
    } else {
      s_unlike += W[i];
    }
  }
  for (int i = 0; i < N; i++) {
    cout << go(L[i], W[i], s_like - (L[i] ? W[i] : 0),
               s_unlike - (L[i] ? 0 : W[i]))
         << '\n';
  }
  return 0;
}
