#include <bits/stdc++.h>
#define EB emplace_back

typedef long long ll;
typedef std::vector <int> vector;
const int N = 5000, M = 66666, mod = 998244353;

struct edge {
	int u, v;
	edge (int u0 = 0, int v0 = 0) : u(u0), v(v0) {}
} e[M];

int R, C, V, E = 0;
int p[N], mat[N][N], elim[N];
int to[M], first[N], next[M];
int orient[M];

inline void addedge(int u, int v) {
//	fprintf(stderr, "addedge %d %d\n", u, v);
	e[++E] = edge(u, v), next[E] = first[u], first[u] = E;
	e[++E] = edge(v, u), next[E] = first[v], first[v] = E;
}

inline int join(int r, int c) {return (r - 1) * C + 1;}
inline void split(int id, int &r, int &c) {r = --id / C + 1, c = id % C + 1;}
inline int ancestor(int x) {return p[x] == x ? x : (p[x] = ancestor(p[x]));}
inline bool Union(int x, int y) {
	if ((x = ancestor(x)) == (y = ancestor(y))) return true;
	return p[x] = y, false;
}

ll PowerMod(ll a, int n, ll c = 1) {for (; n; n >>= 1, a = a * a % mod) if (n & 1) c = c * a % mod; return c;}

int gauss(int n) {
	int i, j, k, *t, det = 1, cnt; ll coe;
	static int *m[N];
	for (i = 0; i < n; ++i) m[i] = mat[i];
	for (i = 0; i < n; ++i) {
		for (j = i; j < n && !m[j][i]; ++j);
		if (j == n) return 0;
		if (i != j) det = mod - det, std::swap(m[i], m[j]);
		det = (ll)det * m[i][i] % mod;
		coe = PowerMod(m[i][i], mod - 2);
		for (j = 0; j < n; ++j) m[i][j] = m[i][j] * coe % mod;
		for (cnt = 0, k = i; k < n; ++k) if (m[i][k]) elim[cnt++] = k;
		for (k = i + 1; k < n; ++k) if (m[k][i]) {
			coe = mod - m[k][i];
			for (t = elim; t != elim + cnt; ++t)
				m[k][*t] = (m[k][*t] + coe * m[i][*t]) % mod;
		}
	}
	return det;
}

namespace Planar {
	#define ad(x) (((x - 1) ^ 1) + 1)
	int F = 0;
	int belF[M], remain[M], que[M];
	vector face[M];

	inline bool judge(int A, int B, int C, int D) {
		if (B == A + ::C) return (D - 1) % ::C < (C - 1) % ::C;
		if (B == A - ::C) return (C - 1) % ::C < (D - 1) % ::C;
		if (B == A + 1) return C < D;
		if (B == A - 1) return D < C;
		abort();
	}

	void dfs(int i) {
		int j, x = e[i].u, y = e[i].v, z, bestV = 0, bestE = 0;
//		fprintf(stderr, "search face #%d edge #%d (%d, %d)\n", F, i, x, y);
		belF[i] = F, face[F].EB(i);
		for (j = first[y]; j; j = next[j]) {
			if ((z = e[j].v) == x) continue;
			if (!bestV || judge(x, y, z, bestV)) bestV = z, bestE = j;
		}
		if (!bestE) {
			for (j = first[y]; j; j = next[j]) if (e[j].v == x) break;
			bestV = x, bestE = j;
		}
		if (belF[bestE] != F) dfs(bestE);
	}

	int main() {
		int i, f, h, t = 0; bool o;
		for (i = 1; i <= E; ++i)
			if (!belF[i]) ++F, dfs(i), remain[F] = face[F].size();
		for (i = 1; i <= F; ++i)
			for (int e : face[i])
				if (orient[e] && --remain[i] == 1) que[t++] = i;
		for (h = 0; h < t; ++h) {
			f = que[h], o = true;
			if (!remain[f]) continue;
			for (int e : face[f])
				if (orient[e]) o ^= orient[e] != e;
				else i = e;
			orient[ad(i)] = orient[i] = (o ? ad(i) : i);
			if (--remain[ f = belF[ad(i)] ] == 1) que[t++] = f;
		}
		for (i = 1; i <= E; ++i) assert(orient[i]);
		return 0;
	}
}

int main() {
	int i, j, v, n;
	scanf("%d%d", &R, &C), V = R * C;
	if (R & C & 1) return putchar(48), putchar(10), 0;
	for (n = i = 1; i <= R; ++i, ++n)
		for (j = 1; j < C; ++j, ++n)
			if (scanf("%d", &v), !v) addedge(n, n + 1);
	for (n = i = 1; i < R; ++i)
		for (j = 1; j <= C; ++j, ++n)
			if (scanf("%d", &v), !v) addedge(n, n + C);
	std::iota(p + 1, p + (V + 1), 1);
	for (i = 1; i <= E; i += 2)
		if (!Union(e[i].u, e[i].v)) {
			orient[i] = orient[i + 1] = i;
//			fprintf(stderr, "connect %d %d\n", e[i].u, e[i].v);
		}
	Planar::main();
	for (i = 1; i <= E; ++i) if (orient[i] == i)
		mat[e[i].u - 1][e[i].v - 1] = 1, mat[e[i].v - 1][e[i].u - 1] = mod - 1;
	printf("%d\n", gauss(V));
	return 0;
}