package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD int64 = 998244353

func modPow(a, e int64) int64 {
	a %= MOD
	if a < 0 {
		a += MOD
	}
	res := int64(1)
	for e > 0 {
		if e&1 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return res
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var n, m int
	fmt.Fscan(in, &n, &m)

	a := make([]int, n)
	w := make([]int64, n)

	for i := 0; i < n; i++ {
		fmt.Fscan(in, &a[i])
	}

	var A, B int64
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &w[i])
		if a[i] == 1 {
			A += w[i]
		} else {
			B += w[i]
		}
	}

	S := A + B
	invDen := make([]int64, 2*m+1)
	for d := -m; d <= m; d++ {
		val := S + int64(d)
		if val > 0 {
			invDen[d+m] = modPow(val, MOD-2)
		}
	}

	invA := modPow(A, MOD-2)
	var invB int64
	if B > 0 {
		invB = modPow(B, MOD-2)
	}

	dp := make([]int64, m+2)
	ndp := make([]int64, m+2)
	dp[0] = 1

	for i := 0; i < m; i++ {
		for k := 0; k <= i+1; k++ {
			ndp[k] = 0
		}
		for j := 0; j <= i; j++ {
			cur := dp[j]
			if cur == 0 {
				continue
			}
			like := A + int64(j)
			dis := B - int64(i-j)
			if dis < 0 {
				continue
			}
			inv := invDen[2*j-i+m]
			if like > 0 {
				v := cur * (like % MOD) % MOD * inv % MOD
				ndp[j+1] += v
				if ndp[j+1] >= MOD {
					ndp[j+1] -= MOD
				}
			}
			if dis > 0 {
				v := cur * (dis % MOD) % MOD * inv % MOD
				ndp[j] += v
				if ndp[j] >= MOD {
					ndp[j] -= MOD
				}
			}
		}
		dp, ndp = ndp, dp
	}

	var expLike, expDis int64
	for j := 0; j <= m; j++ {
		if dp[j] == 0 {
			continue
		}
		expLike = (expLike + dp[j]*((A+int64(j))%MOD)) % MOD
		if B > 0 {
			disFinal := B - int64(m-j)
			if disFinal >= 0 {
				expDis = (expDis + dp[j]*(disFinal%MOD)) % MOD
			}
		}
	}

	for i := 0; i < n; i++ {
		var ans int64
		if a[i] == 1 {
			ans = (w[i] % MOD) * invA % MOD * expLike % MOD
		} else {
			ans = (w[i] % MOD) * invB % MOD * expDis % MOD
		}
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, ans)
	}
	fmt.Fprintln(out)
}