#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int mod = 2; // assert mod is prime

template<int M>
struct Mint{
	int x;
	Mint() : x(0){}
	Mint(int y) : x(y >= 0 ? y % M : M - (-y) % M){}
	Mint &operator += (const Mint &rhs){ if((x += rhs.x) >= M) x -= M; return *this; }
	Mint &operator -= (const Mint &rhs){ if((x += M - rhs.x) >= M) x -= M; return *this; }
	Mint &operator *= (const Mint &rhs){ x = 1LL * x*rhs.x % M; return *this; }
	Mint &operator /= (const Mint &rhs){ x = (1LL * x*rhs.inv().x) % M; return *this; }
	Mint operator - () const{ return Mint(-x); }
	Mint operator + (const Mint &rhs) const{ return Mint(*this) += rhs; }
	Mint operator - (const Mint &rhs) const{ return Mint(*this) -= rhs; }
	Mint operator * (const Mint &rhs) const{ return Mint(*this) *= rhs; }
	Mint operator / (const Mint &rhs) const{ return Mint(*this) /= rhs; }
	bool operator < (const Mint &rhs) const{ return x < rhs.x; }
	Mint inv() const{
		signed a = x, b = M, u = 1, v = 0, t;
		while(b){ t = a / b; a -= t * b; swap(a, b); u -= t * v; swap(u, v); }
		return Mint(u);
	}
	Mint pow(long long t) const{
		Mint e = *this, res = 1;
		for(; t; e *= e, t >>= 1) if(t & 1) res *= e;
		return res;
	}
};
template <int M>
ostream &operator << (ostream &os, const Mint<M> &rhs){
	return os << rhs.x;
}
template <int M>
istream &operator >> (istream &is, Mint<M> &rhs){
	long long s; is >> s; rhs = Mint<M>(s); return is;
};

using mint = Mint<mod>;

using Array = vector<mint>;
using Matrix = vector<Array>;
const double eps = 1e-10;

void outMat(const Matrix& A){
	int n = A.size(), m = A[0].size();
	for(int i = 0; i < n; i++){
		for(int j = 0; j < m; j++){
			cout << A[i][j] << " ";
		}
		cout << endl;
	}
	cout << endl;
}

Array GaussJordan(const Matrix& A, const Array& b){
	int n = A.size();
	Matrix B(n, Array(n + 1));
	for(int i = 0; i < n; i++)
		for(int j = 0; j < n; j++)	B[i][j] = A[i][j];
	for(int i = 0; i < n; i++) B[i][n] = b[i];
	for(int i = 0; i < n; i++){
		int pivot = i;
		for(int j = i; j < n; j++){
			if(B[j][i].x > B[pivot][i].x) pivot = j;
			//if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
		}
		//outMat(B);
		swap(B[i], B[pivot]);
		//outMat(B);

		//if(abs(B[i][i]) < eps) return Array();
		for(int j = i + 1; j <= n; j++) B[i][j] /= B[i][i];
		for(int j = 0; j < n; j++){
			if(i != j){
				for(int k = i + 1; k <= n; k++) B[j][k] -= B[j][i] * B[i][k];
			}
		}
		//outMat(B);
	}

	//outMat(B);

	Array x(n);
	for(int i = 0; i < n; i++) x[i] = B[i][n];
	return x;
}

int b[25][25];

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
#ifdef LOCAL
	std::ifstream in("in");
	std::cin.rdbuf(in.rdbuf());
#endif

	int m, n, d;
	while(cin >> m >> n >> d, m){
		int N = n * m;
		for(int i = 0; i < n; i++){
			for(int j = 0; j < m; j++){
				cin >> b[i][j];
			}
		}

		Matrix A(N, Array(N));
		Array B(N);
		for(int i1 = 0; i1 < n; i1++){
			for(int j1 = 0; j1 < m; j1++){
				for(int i2 = 0; i2 < n; i2++){
					for(int j2 = 0; j2 < m; j2++){
						int D = abs(i1 - i2) + abs(j1 - j2);
						A[i1 * m + j1][i2 * m + j2] = (D == 0 || D == d);
					}
				}
				B[i1 * m + j1] = b[i1][j1];
			}
		}
		//outMat(A);
		auto X = GaussJordan(A, B);

		int ok = 1;
		for(int i = 0; i < N; i++){
			mint k = 0;
			for(int j = 0; j < N; j++){
				k += A[i][j] * X[j];
			}
			if(k.x != B[i].x){
				ok = 0;
				break;
			}
		}

		cout << ok << endl;
	}
}

Measured memory_bytes: 6000