#include <cstdio>

#pragma GCC target("popcnt")

typedef unsigned int uint;
typedef long long unsigned int uint64;

int exgcd(const int a, const int b, int &x, int &y)
{
	if (b == 0)
	{
		x = 1, y = 0;
		return a;
	}
	int d = exgcd(b, a % b, y, x);
	y -= a / b * x;
	return d;
}

const uint Mod = 998244353;

struct Z
{
	uint v;
	Z() { }
	Z(const uint _v) : v(_v) { }
};

inline Z operator+(const Z &x1, const Z &x2) { return x1.v + x2.v < Mod ? x1.v + x2.v : x1.v + x2.v - Mod; }
inline Z operator-(const Z &x1, const Z &x2) { return x1.v >= x2.v ? x1.v - x2.v : x1.v + Mod - x2.v; }
inline Z operator-(const Z &x) { return x.v ? Mod - x.v : 0; }
inline Z operator*(const Z &x1, const Z &x2) { return static_cast<uint64>(x1.v) * x2.v % Mod; }
inline Z &operator+=(Z &x1, const Z &x2) { x1.v = x1.v + x2.v < Mod ? x1.v + x2.v : x1.v + x2.v - Mod; return x1; }
inline Z &operator-=(Z &x1, const Z &x2) { x1.v = x1.v >= x2.v ? x1.v - x2.v : x1.v + Mod - x2.v; return x1; }
inline Z &operator*=(Z &x1, const Z &x2) { x1.v = static_cast<uint64>(x1.v) * x2.v % Mod; return x1; }

Z Rec(const Z x)
{
	int res, tmp;
	exgcd(x.v, Mod, res, tmp);
	return res < 0 ? res + Mod : res;
}

Z _Rec[22];

Z Power(Z Base, int Exp)
{
	if (Exp < 0)
		Base = Rec(Base), Exp = -Exp;
	Z res = 1;
	for (; Exp; Base *= Base, Exp >>= 1)
		if (Exp & 1)
			res *= Base;
	return res;
}

void zt(Z F[1 << 21][22], const int n)
{
	for (int d = 1; d != 1 << n; d <<= 1)
		for (int i = 0; i != 1 << n; i += d << 1)
			for (int j = 0; j != d; ++j)
				for (int k = 0; k <= n; ++k)
					F[i + d + j][k] += F[i + j][k];
}

void mt(Z F[1 << 21][22], const int n)
{
	for (int d = 1; d != 1 << n; d <<= 1)
		for (int i = 0; i != 1 << n; i += d << 1)
			for (int j = 0; j != d; ++j)
				for (int k = 0; k <= n; ++k)
					F[i + d + j][k] -= F[i + j][k];
	for (int s = 0; s != 1 << n; ++s)
		for (int k = 0; k <= n; ++k)
			if (k != __builtin_popcount(s))
				F[s][k] = 0;
}

void Exp(const Z A[22], int n, Z res[22])
{
	static uint tmp[22];
	res[0] = 1;
	if (n <= 18)
	{
		for (int i = 1; i <= n; ++i)
		{
			tmp[i] = (i * A[i]).v;
			uint64 _tmp = 0;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			res[i] = _Rec[i] * (_tmp % Mod);
		}
	}
	else
	{
		for (int i = 1; i <= 18; ++i)
		{
			tmp[i] = (i * A[i]).v;
			uint64 _tmp = 0;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			res[i] = _Rec[i] * (_tmp % Mod);
		}
		for (int i = 19; i <= n; ++i)
		{
			tmp[i] = (i * A[i]).v;
			uint64 _tmp = 0;
			for (int j = 1; j <= 18; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			_tmp %= Mod;
			for (int j = 19; j <= i; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			res[i] = _Rec[i] * (_tmp % Mod);
		}
	}
}

void Exp(Z F[1 << 21][22], const int n)
{
	zt(F, n);
	for (int s = 0; s != 1 << n; ++s)
		Exp(F[s], n, F[s]);
	mt(F, n);
}

Z c_Exp(Z F[1 << 21][22], const int n)
{
	Z res = 0;
	zt(F, n);
	for (int s = 0; s != 1 << n; ++s)
		Exp(F[s], n, F[s]), res += (n - __builtin_popcount(s)) & 1 ? -F[s][n] : F[s][n];
	return res;
}

void Log(const Z A[22], int n, Z res[22])
{
	static uint nA[22];
	for (int i = 0; i <= n; ++i)
		nA[i] = (-A[i]).v;
	static uint tmp[22];
	tmp[0] = 0;
	if (n <= 17)
	{
		for (int i = 1; i <= n; ++i)
		{
			uint64 _tmp = static_cast<uint64>(i) * A[i].v;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			tmp[i] = _tmp % Mod;
		}
	}
	else
	{
		for (int i = 1; i <= 17; ++i)
		{
			uint64 _tmp = static_cast<uint64>(i) * A[i].v;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			tmp[i] = _tmp % Mod;
		}
		for (int i = 18; i <= n; ++i)
		{
			uint64 _tmp = static_cast<uint64>(i) * A[i].v;
			for (int j = 1; j <= 17; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			_tmp %= Mod;
			for (int j = 18; j <= i; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			tmp[i] = _tmp % Mod;
		}
	}
	for (int i = 0; i <= n; ++i)
		res[i] = _Rec[i] * tmp[i];
}

Z c_Log(Z F[1 << 21][22], const int n)
{
	Z res = 0;
	zt(F, n);
	for (int s = 0; s != 1 << n; ++s)
		Log(F[s], n, F[s]), res += (n - __builtin_popcount(s)) & 1 ? -F[s][n] : F[s][n];
	return res;
}

void Power(const Z A[22], int n, uint exp, Z res[22])
{
	static uint nA[22];
	for (int i = 0; i <= n; ++i)
		nA[i] = (-A[i]).v;
	static uint tmp[22];
	tmp[0] = 0;
	if (n <= 17)
	{
		for (int i = 1; i <= n; ++i)
		{
			uint64 _tmp = static_cast<uint64>(i) * A[i].v;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			tmp[i] = _tmp % Mod;
		}
	}
	else
	{
		for (int i = 1; i <= 17; ++i)
		{
			uint64 _tmp = static_cast<uint64>(i) * A[i].v;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			tmp[i] = _tmp % Mod;
		}
		for (int i = 18; i <= n; ++i)
		{
			uint64 _tmp = static_cast<uint64>(i) * A[i].v;
			for (int j = 1; j <= 17; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			_tmp %= Mod;
			for (int j = 18; j <= i; ++j)
				_tmp += static_cast<uint64>(nA[j]) * tmp[i - j];
			tmp[i] = _tmp % Mod;
		}
	}
	
	for (int i = 1; i <= n; ++i)
		tmp[i] = (Z(tmp[i]) * exp).v;
	
	res[0] = 1;
	if (n <= 18)
	{
		for (int i = 1; i <= n; ++i)
		{
			uint64 _tmp = 0;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			res[i] = _Rec[i] * (_tmp % Mod);
		}
	}
	else
	{
		for (int i = 1; i <= 18; ++i)
		{
			uint64 _tmp = 0;
			for (int j = 1; j <= i; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			res[i] = _Rec[i] * (_tmp % Mod);
		}
		for (int i = 19; i <= n; ++i)
		{
			uint64 _tmp = 0;
			for (int j = 1; j <= 18; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			_tmp %= Mod;
			for (int j = 19; j <= i; ++j)
				_tmp += static_cast<uint64>(tmp[j]) * res[i - j].v;
			res[i] = _Rec[i] * (_tmp % Mod);
		}
	}
	/*
	static Z tmp[22];
	tmp[0] = 1;
	for (int i = 1; i <= n; ++i)
	{
		Z _tmp = 0, coef = -Z(i);
		for (int j = 1; j <= i; ++j)
			coef += exp + 1, _tmp += coef * A[j] * tmp[i - j];
		tmp[i] = _tmp * _Rec[i];
	}
	for (int i = 0; i <= n; ++i)
		res[i] = tmp[i];
	*/
}

Z c_Power(Z F[1 << 21][22], const int n, const uint exp)
{
	Z res = 0;
	zt(F, n);
	for (int s = 0; s != 1 << n; ++s)
		Power(F[s], n, exp, F[s]), res += (n - __builtin_popcount(s)) & 1 ? -F[s][n] : F[s][n];
	return res;
}

Z Tutte_c(const int G[], const int n, const int x, const int y)
{
	static Z F[1 << 21][22];
	for (int s = 1; s != 1 << n; ++s)
		for (int i = 0; i <= n; ++i)
			F[s][i] = 0;
	if (y == 1)
	{
		F[1][1] = 1;
		for (int i = 1; i != n; ++i)
		{
			for (int s = 0; s != 1 << i; ++s)
				F[1 << i | s][__builtin_popcount(s)] = F[s][__builtin_popcount(s)] * __builtin_popcount(s & G[i]);
			Exp(F + (1 << i), i);
			for (int s = 0; s != 1 << i; ++s)
				F[1 << i | s][__builtin_popcount(s) + 1] = F[1 << i | s][__builtin_popcount(s)], F[1 << i | s][__builtin_popcount(s)] = 0;
			F[1 << i][1] = 1;
		}
		if (x == 1)
			return F[(1 << n) - 1][n];
		for (int s = 0; s != 1 << n; ++s)
			F[s][__builtin_popcount(s)] = F[s][__builtin_popcount(s)] * (Z(x) - 1);
		return Rec(Z(x) - 1) * c_Exp(F, n);
	}
	F[0][0] = 1;
	for (int s = 1; s != 1 << n; ++s)
	{
		uint cnt = 0;
		for (int t = s; t; t &= t - 1)
			cnt += __builtin_popcount(G[__builtin_ctz(t)] & t);
		F[s][__builtin_popcount(s)] = Power(y, cnt);
	}
	if (x == 1)
		return Power(Z(y) - 1, 1 - n) * c_Log(F, n);
	return Rec(Z(x) - 1) * Power(Z(y) - 1, -n) * c_Power(F, n, ((Z(x) - 1) * (Z(y) - 1)).v);
}

Z Tutte(const int G[], const int n, const int x, const int y)
{
	int r = (1 << n) - 1;
	Z res = 1;
	while (r)
	{
		int s, ts = r & -r;
		do
		{
			s = ts;
			for (int t = s; t; t &= t - 1)
				ts |= G[__builtin_ctz(t)];
		} while (ts != s);
		static int tmp[21];
		for (int i = 0; i != __builtin_popcount(s); ++i)
			tmp[i] = 0;
		for (int ti = s, i = 0; ti; ti &= ti - 1, ++i)
			for (int tj = s, j = 0; tj; tj &= tj - 1, ++j)
				tmp[i] |= (G[__builtin_ctz(ti)] >> __builtin_ctz(tj) & 1) << j;
		res = res * Tutte_c(tmp, __builtin_popcount(s), x, y);
		r &= ~s;
	}
	return res;
}

int N, x, y, G[21];

int main(int argc, char **argv)
{
	scanf("%d", &N);
	
	_Rec[1] = 1;
	for (int i = 2; i <= N; ++i)
		_Rec[i] = (Mod - Mod / i) * _Rec[Mod % i];
	
	for (int i = 0, f; i != N; ++i)
		for (int j = 0; j != N; ++j)
			scanf("%d", &f), G[i] |= f << j;
	scanf("%d %d", &x, &y);
	printf("%u\n", Tutte(G, N, x, y).v);

	return 0;
}