#include <bits/stdc++.h>

using namespace std;

#define lep(i, l, r) for(int i = (l); i <= (r); i ++)
#define rep(i, l, r) for(int i = (l); i >= (r); i --)
#define Lep(i, l, r) for(int i = (l); i <  (r); i ++)
#define debug(...) fprintf (stderr, __VA_ARGS__)

using i64 = long long;
using ld = long double;
using ui64 = unsigned long long;

const int P = 998244353;
inline int mod(int x) { return x + (x >> 31 & P); }
inline void pls(int &x, int y) { x = mod(x + y - P); }
inline void sub(int &x, int y) { x = mod(x - y); }
inline int  add(int x, int y) { return mod (x + y - P); }
inline int  dec(int x, int y) { return mod (x - y); }

inline int power(int x, int k) {
	int res = 1;
	while(k) {
		if (k & 1) res = 1ll * res * x % P;
		x = 1ll * x * x % P; k >>= 1;
	} return res;
}

/*

f(a, b, k, i)

for bit

k = 0
0 1 / 1 0 
0 0 / 1 1

*/

const int N = 400 + 5;

int C[N][N], fac[N];
void init(int n = 400) {
	C[0][0] = 1;
	fac[0] = 1;
	lep (i, 1, n) fac[i] = 1ll * fac[i - 1] * i % P;
	lep (i, 1, n) {
		C[i][0] = 1;
		lep (j, 1, i) {
			C[i][j] = add(C[i - 1][j], C[i - 1][j - 1]);
		}
	}
}

int n;
i64 k;

vector<int> solve(vector<i64> a, vector<i64> b, i64 k, int bit) {
	if (a.size() == 0 || b.size() == 0) return {1};

	if (bit < 0) {
		int sz = min (a.size(), b.size());
		vector<int> res(sz + 1);
		for (int i = 0; i <= sz; i ++) {
			res[i] = C[a.size()][i] * 1ll * C[b.size()][i] % P * fac[i] % P;
		}
		
		return res;
	}

	if (! (k & (1ll << bit)) ) {

		vector<i64> a0, a1, b0, b1;
		for (auto x : a) {
			if (x & (1ll << bit)) a1.push_back(x);
			else a0.push_back(x);
		}
		for (auto x : b) {
			if (x & (1ll << bit)) b1.push_back(x);
			else b0.push_back(x);
		}

		auto dpa0b0 = solve(a0, b0, k, bit - 1);
		auto dpa1b1 = solve(a1, b1, k, bit - 1);
		
		int sz = min(a.size(), b.size());
		vector<int> res(sz + 1);

		for (int i = 0; i < dpa0b0.size(); i ++)
			for (int j = 0; j < dpa1b1.size(); j ++) {
				int tmp = dpa0b0[i] * 1ll * dpa1b1[j] % P;

				int A0 = a0.size() - i, A1 = a1.size() - j, B0 = b0.size() - i, B1 = b1.size() - j;
				int x = min(A0, B1), y = min(A1, B0);

				lep (p, 0, x) lep (q, 0, y) {
					int v = 1ll * tmp * C[A0][p] % P * C[B1][p] % P * C[B0][q] % P * C[A1][q] % P * fac[p] % P * fac[q] % P;
					pls(res[i + j + p + q], v);
				}
			}

		return res;

	} else {
		vector<i64> a0, a1, b0, b1;
		for (auto x : a) {
			if (x & (1ll << bit)) a1.push_back(x);
			else a0.push_back(x);
		}
		for (auto x : b) {
			if (x & (1ll << bit)) b1.push_back(x);
			else b0.push_back(x);
		}

		auto dpa0b1 = solve(a0, b1, k, bit - 1);
		auto dpa1b0 = solve(a1, b0, k, bit - 1);

		int sz = min(a.size(), b.size());
		vector<int> res(sz + 1);
		for (int i = 0; i < dpa0b1.size(); i ++)
			for (int j = 0; j < dpa1b0.size(); j ++) 
				pls(res[i + j], dpa0b1[i] * 1ll * dpa1b0[j] % P);

		return res;
	}
}

int main() {
	ios :: sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	init();
	cin >> n >> k;
	vector<i64> a(n), b(n);
	for (auto &x : a) cin >> x;
	for (auto &x : b) cin >> x;
	auto dp = solve (a, b, k, 60);
	lep (i, 1, n) cout << dp[i] << '\n';
	return 0;
}