// Test brute force solution
#include <bits/stdc++.h>

const int mod = 998244353;
inline int inc(int x, int y) { x += y - mod; return x + (x >> 31 & mod); }
inline int dec(int x, int y) { x -= y; return x + (x >> 31 & mod); }
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline void upd(int &x, int y) { x = inc(x, y); }
inline void dpu(int &x, int y) { x = dec(x, y); }
inline void pud(int &x, int y) { x = mul(x, y); }
inline int fastpow(int x, int p) {
	int r = 1;
	while (p) {
		if (p & 1) pud(r, x);
		pud(x, x);
		p >>= 1;
	}
	return r;
}

typedef std::vector<int> poly;

inline poly inc(poly x, poly y) {
	int t = std::max(x.size(), y.size());
	x.resize(t), y.resize(t);
	poly z(t);
	for (int i = 0; i < t; ++i)
		z[i] = inc(x[i], y[i]);
	return z;
}
inline void upd(poly &x, poly y) {
	x = inc(x, y);
}
inline poly dec(poly x, poly y) {
	int t = std::max(x.size(), y.size());
	x.resize(t), y.resize(t);
	poly z(t);
	for (int i = 0; i < t; ++i)
		z[i] = dec(x[i], y[i]);
	return z;
}
inline poly mul(poly x, poly y) {
	int nx = x.size(), ny = y.size();
	poly z(nx + ny - 1);
	for (int i = 0; i < nx; ++i)
		for (int j = 0; j < ny; ++j)
			upd(z[i + j], mul(x[i], y[j]));
	return z;
}


// solve det(A + I * z)
auto solve(int n, std::vector<std::vector<int>> a) {
	auto swap_row = [&](int i, int j) {
		for (int k = 0; k < n; ++k)
			std::swap(a[i][k], a[j][k]);
	};
	auto swap_col = [&](int i, int j) {
		for (int k = 0; k < n; ++k)
			std::swap(a[k][i], a[k][j]);
	};
	auto add_row = [&](int i, int j, int t) {
		for (int k = 0; k < n; ++k) {
			upd(a[i][k], mul(a[j][k], t));
		}
	};
	auto add_col = [&](int i, int j, int t) {
		for (int k = 0; k < n; ++k) {
			upd(a[k][i], mul(a[k][j], t));
		}
	};
	auto debug = [&]() {
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) printf("%d ", a[i][j]);
			putchar('\n');
		}
	};
	auto gauss = [&]() {
		for (int i = 0; i + 1 < n; ++i) {
			int k = -1;
			for (int j = i + 1; j < n; ++j)
				if (a[j][i]) {
					k = j;
					break;
				}
			if (k == -1) continue;
			swap_row(i + 1, k);
			swap_col(i + 1, k);
			assert(a[i + 1][i] != 0);
			for (int j = i + 2; j < n; ++j) {
				int t = mul(a[j][i], fastpow(a[i + 1][i], mod - 2));
				add_row(j, i + 1, dec(0, t));
				add_col(i + 1, j, t);
				for (int z = 0; z <= i; ++z) {
					assert(a[j][z] == 0);
				}
			}
		}
	};
	gauss();
	std::vector<std::vector<int>> f(n, std::vector<int>());
	// det(I * z - S)
	auto output = [&](poly &P) {
		printf("poly: ");
		for (int x : P)
			printf("%d, ", x);
		putchar('\n');
	};
	f[0] = { a[0][0], 1 };
	for (int i = 1; i < n; ++i) {
		f[i] = mul(f[i - 1], poly{ a[i][i], 1 });
		int prod = a[i][i - 1], sgn = mod - 1;
		for (int j = i - 1; j >= 0; --j) {
			// f[i] += prod * a[j][n] * f[j - 1]
			poly z{1};
			if (j) z = f[j - 1];
			poly r = mul(z, poly{mul(a[j][i], mul(sgn, prod))});
			upd(f[i], r);
			if (j) pud(prod, a[j][j - 1]);
			sgn = dec(0, sgn);
		}
	}
	f[n - 1].resize(n + 1);
	return f[n - 1];
}

struct F2 {
	int a, b; // a + b * z
	F2(int a = 0, int b = 0) : a(a), b(b){
		
	}	
};

inline F2 inc(const F2 &lhs, const F2 &rhs) {
	return F2(inc(lhs.a, rhs.a), inc(lhs.b, rhs.b));
}
inline F2 dec(const F2 &lhs, const F2 &rhs) {
	return F2(dec(lhs.a, rhs.a), dec(lhs.b, rhs.b));
}
inline F2 mul(const F2 &lhs, int k) {
	return F2(mul(lhs.a, k), mul(lhs.b, k));
}
inline void upd(F2 &lhs, const F2 &rhs) {
	lhs = inc(lhs, rhs);
}
inline void pud(F2 &lhs, int k) {
	lhs = mul(lhs, k);
}

poly solve(int n, std::vector<std::vector<F2>> M) {
	poly f(n);
	int left_shift = 0;
	int sgn = 1;
	auto swap_row = [&](int i, int j) {
		if (i != j) {
			for (int k = 0; k < n; ++k)
				std::swap(M[i][k], M[j][k]);
			sgn = dec(0, sgn);
		}
	};
	auto swap_col = [&](int i, int j) {
		if (i != j) {
			for (int k = 0; k < n; ++k)
				std::swap(M[k][i], M[k][j]);
			sgn = dec(0, sgn);
		}
	};
	auto multiply_row = [&](int i) {
		for (int k = 0; k < n; ++k) {
			assert(M[i][k].b == 0);
			M[i][k].b = M[i][k].a;
			M[i][k].a = 0;
		}
		++left_shift;
	};
	// M[i][*] += M[j][*] * t
	auto add_row = [&](int i, int j, int t) {
		for (int k = 0; k < n; ++k) {
			auto z = mul(M[j][k], t);
			upd(M[i][k], mul(M[j][k], t));
		}
	};
	auto debug = [&]() {
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
			}
			putchar('\n');
		}
	};
	for (int i = 0; i < n; ++i) {
		for (int t = 0; t < i; ++t)
			assert(M[i][t].b == 0);
		int j = -1;
		for (int t = i; t < n; ++t)
			if (M[i][t].b != 0) {
				j = t;
				break;
			}
		while (j == -1) {
			multiply_row(i);
			for (int t = 0; t < i; ++t) {
				if (M[i][t].b != 0) {
					assert(M[t][t].b != 0);
					int k = mul(M[t][t].b, fastpow(M[i][t].b, mod - 2));
					add_row(i, t, k);
					assert(M[i][t].b == 0);
				}
			}
			for (int t = i; t < n; ++t) {
				if (M[i][t].b != 0) {
					j = t;
					break;
				}
			}
			if (left_shift > n) return f;
		}
		if (i != j) swap_col(i, j);
		for (int t = 0; t < i; ++t)
			assert(M[i][t].b == 0);
		for (int j = 0; j < n; ++j) if (i != j && M[j][i].b != 0) {
			int t = mul(fastpow(M[i][i].b, mod - 2), M[j][i].b);
			add_row(j, i, dec(0, t));
			assert(M[j][i].b == 0);
		}
	}
	for (int i = 0; i < n; ++i) {
		assert(M[i][i].b != 0);
		pud(sgn, M[i][i].b);
		int t = fastpow(M[i][i].b, mod - 2);
		for (int j = 0; j < n; ++j)
			pud(M[i][j], t);
		assert(M[i][i].b == 1);
	}	
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j)
			if (i != j)
				assert(M[i][j].b == 0);
			else assert(M[i][j].b == 1);
	std::vector<std::vector<int>> a(n, std::vector<int>(n));
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j) {
			a[i][j] = M[i][j].a;
		}
	f = solve(n, a);
	poly g(n + 1);
	for (int i = 0; i <= n; ++i) {
		pud(f[i], sgn);
	}
	for (int i = 0; i + left_shift <= n; ++i) {
		if (i + left_shift <= n) {
			g[i] = f[i + left_shift];
		}
	}
	return g;
}

inline int det(int n, std::vector<std::vector<int>> a) {
	int prod = 1;
	auto debug = [&]() {
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) printf("%d ", a[i][j]);
			putchar('\n');
		}
	};
	for (int i = 0; i < n; ++i) {
		int k = -1;
		for (int j = i; j < n; ++j)
			if (a[j][i] != 0) {
				k = j;
				break;
			}
		if (k == -1) return 0;
		if (k != i) {
			for (int j = 0; j < n; ++j)
				std::swap(a[i][j], a[k][j]);
			prod = dec(0, prod);
		}
		for (int j = 0; j < n; ++j)
			if (i != j && a[j][i]) {
				int t = mul(a[j][i], fastpow(a[i][i], mod - 2));
				for (int k = 0; k < n; ++k) {
					dpu(a[j][k], mul(a[i][k], t));
				}
				assert(a[j][i] == 0);
			}
	}
	for (int i = 0; i < n; ++i)
		pud(prod, a[i][i]);
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j)
			if (i != j)
				assert(a[i][j] == 0);
	return prod;
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);
	int n;
	std::cin >> n;
	std::vector<std::vector<F2>> M(n, std::vector<F2>(n));
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j) {
			std::cin >> M[i][j].a;
		}
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j) {
			std::cin >> M[i][j].b;
		}
	std::vector<std::vector<int>> a(n, std::vector<int>(n));
	std::vector<int> g(n + 1);
	for (int k = 0; k <= n; ++k) {
		for (int i = 0; i < n; ++i) 
			for (int j = 0; j < n; ++j)
				a[i][j] = inc(M[i][j].a, mul(k, M[i][j].b));
		g[k] = det(n, a);
	}
	poly z{};
	for (int i = 0; i <= n; ++i) {
		poly ret{g[i]};
		for (int j = 0; j <= n; ++j)
			if (i != j) {
				int t = fastpow(dec(i, j), mod - 2);
				int c = mul(dec(0, j), t);
				poly cur{c, t};
				ret = mul(ret, cur);
			}
		z = inc(z, ret);
	}
	for (int i = 0; i <= n; ++i) printf("%d ", z[i]);
}