#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

inline int countPopulation(unsigned int x) {
	x -= ((x >> 1) & 0x55555555);
	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
	x = ((x >> 4) + x) & 0x0f0f0f0f;
	x += (x >> 8);
	x += (x >> 16);
	return (x & 0x0000003f);
}

inline int countPopulation64(unsigned long long x) {
	return countPopulation(x & 0xffffffff) + countPopulation(x >> 32);
}


struct BitSet {
	typedef unsigned long long uint64;
	static const int MAX_BIT_LENGTH = int(25*25+1);
	uint64 bits[(MAX_BIT_LENGTH + 0x3f)>>6];
	int size, last;
	uint64 lastMask;

	BitSet(){}

	void init(const int size_) {
		size = size_;
		last = (size+0x3f)>>6;
		lastMask = (1ULL<<(size&0x3f)) - 1;
		memset(bits, 0, sizeof(uint64)*last);
	}

	inline int getIthBit(const int i) const {
		return (bits[i>>6]>>(i&0x3f))&1;
	}

	inline int operator [](const int i) const {
		return getIthBit(i);
	}

	inline void flip(const int i) {
		bits[i>>6] ^= (1ULL<<(i&0x3f));
	}

	inline void turnOn(const int i) {
		bits[i>>6] |= (1ULL<<(i&0x3f));
	}

	inline void turnOff(const int i) {
		bits[i>>6] &= ~(1ULL<<(i&0x3f));
	}

	inline void allFlip() {
		for (int i = 0; i < last - 1; ++i) {
			bits[i] ^= ~0ULL;
		}
		bits[last - 1] ^= lastMask;
	}

	inline void allTurnOn() {
		memset(bits, ~0, sizeof(uint64)*(last - 1));
		bits[last-1] = lastMask;
	}

	inline void allTurnOff() {
		memset(bits, 0, sizeof(uint64)*last);
	}

	inline void rangeFlip(const int from, const int to) {
		const int beg = from >> 6, ed = to >> 6;
		const uint64 begMask = ~((1ULL<<(from&0x3f)) - 1), edMask = (1ULL<<(to&0x3f)) - 1;
		for (int i = from + 1; i < ed; ++i) {
			bits[i] ^= ~0ULL;
		}
		if (beg == ed) {
			bits[beg] ^= begMask & edMask;
		}
		else {
			bits[beg] ^= begMask;
			bits[ed]  ^= edMask;
		}
	}

	inline void rangeTurnOn(const int from, const int to) {
		const int beg = from >> 6, ed = to >> 6;
		const uint64 begMask = ~((1ULL<<(from&0x3f)) - 1), edMask = (1ULL<<(to&0x3f)) - 1;
		for (int i = from + 1; i < ed; ++i) {
			bits[i] = ~0ULL;
		}
		if (beg == ed) {
			bits[beg] |= begMask & edMask;
		}
		else {
			bits[beg] |= begMask;
			bits[ed]  |= edMask;
		}
	}

	inline void rangeTurnOff(const int from, const int to) {
		const int beg = from >> 6, ed = to >> 6;
		const uint64 begMask = ~((1ULL<<(from&0x3f)) - 1), edMask = (1ULL<<(to&0x3f)) - 1;
		for (int i = from + 1; i < ed; ++i) {
			bits[i] = 0;
		}
		if (beg == ed) {
			bits[beg] &= ~(begMask & edMask);
		}
		else {
			bits[beg] &= ~begMask;
			bits[ed]  &= ~edMask;
		}
	}

	inline int countPopulation() const {
		int ans = 0;
		for (int i = 0; i < last; ++i) {
			ans += countPopulation64(bits[i]);
		}
		return ans;
	}

	inline int countRangePopulation(const int from, const int to) const {
		const int beg = from >> 6, ed = to >> 6;
		const uint64 begMask = ~((1ULL<<(from&0x3f)) - 1), edMask = (1ULL<<(to&0x3f)) - 1;
		int ans = 0;
		for (int i = from + 1; i < ed; ++i) {
			ans += countPopulation64(bits[i]);
		}
		if (beg == ed) {
			ans += countPopulation64(bits[beg] &~ (begMask & edMask));
		}
		else {
			ans += countPopulation64(bits[beg] &~ begMask);
			ans += countPopulation64(bits[ed]  &~ edMask);
		}
		return ans;
	}

	BitSet operator& (const BitSet &x) const {
		BitSet ret = *this;
		for (int i = 0; i < last; ++i) {
			ret.bits[i] &= x.bits[i];
		}
		return ret;
	}

	BitSet operator| (const BitSet &x) const {
		BitSet ret = *this;
		for (int i = 0; i < last; ++i) {
			ret.bits[i] |= x.bits[i];
		}
		return ret;
	}

	BitSet operator^ (const BitSet &x) const {
		BitSet ret = *this;
		for (int i = 0; i < last; ++i) {
			ret.bits[i] ^= x.bits[i];
		}
		return ret;
	}

	BitSet operator~ () const {
		BitSet ret = *this;
		ret.allFlip();
		return ret;
	}

	BitSet &operator^= (const BitSet &x) {
		for (int i = 0; i < last; ++i) {
			bits[i] ^= x.bits[i];
		}
		return *this;
	}

	BitSet &operator&= (const BitSet &x) {
		for (int i = 0; i < last; ++i) {
			bits[i] &= x.bits[i];
		}
		return *this;
	}

	BitSet &operator|= (const BitSet &x) {
		for (int i = 0; i < last; ++i) {
			bits[i] |= x.bits[i];
		}
		return *this;
	}
};


int calcEquationSystemMod2(vector<BitSet> &Ab, BitSet& x) {
	const int n = Ab.size(), m = Ab[0].size - 1;
	x.init(m);
	bool uniq = true;
	int val = 0;
	for (int i = 0; i < n; ++i) {
		if (val == m) {
			for (int j = i; j < n; ++j) {
				if (Ab[j][val]) {
					return 0;
				}
			}
			break;
		}
		int foundOne = -1;
		for (int j = i; j < n; ++j) {
			if (Ab[j][val]) {
				foundOne = j;
				break;
			}
		}
		if (foundOne >= 0) {
			swap(Ab[i], Ab[foundOne]);
			for (int j = i + 1; j < n; ++j) {
				if (Ab[j][val]) {
					Ab[j] ^= Ab[i];
				}
			}
		}
		else {
			uniq = false;
			for (int j = 0; j < i; ++j) {
				Ab[j].turnOff(val);
			}
			--i;
		}
		++val;
	}

	val = m - 1;
	int i = n - 1;
	for (;i >= 0 && val >= 0; --val) {
		if (Ab[i][val]) {
			if (Ab[i][m]) {
				x.turnOn(val);
				for (int j = 0; j < i; ++j) {
					Ab[j].turnOff(val);
					Ab[j].flip(m);
				}
			}
			else {
				for (int j = 0; j < i; ++j) {
					Ab[j].turnOff(val);
				}
			}
			--i;
		}
	}

	return uniq ? 1 : -1;
}

const int MAX_N = 25;
int W, H, D;
int board[MAX_N][MAX_N];

inline int toIndex(int y, int x) {
	return y * W + x;
}

bool init() {
	scanf("%d%d%d", &W, &H, &D);
	for (int i = 0; i < H; ++i) {
		for (int j = 0; j < W; ++j) {
			scanf("%d", board[i] + j);
		}
	}
	return H > 0;
}

inline int getDist(int y1, int x1, int y2, int x2) {
	return abs(y1 - y2) + abs(x1 - x2);
}

bool solve() {
	vector<BitSet> matrix(W*H);
	for (int i = 0; i < W*H; ++i) {
		matrix[i].init(W*H+1);
	}

	for (int i = 0; i < H; ++i) {
		for (int j = 0; j < W; ++j) {
			matrix[toIndex(i,j)].turnOn(toIndex(i,j));
			if (board[i][j]) {
				matrix[toIndex(i,j)].turnOn(W*H);
			}
			for (int ii = 0; ii < H; ++ii) {
				for (int jj = 0; jj < W; ++jj) {
					if (getDist(i,j,ii,jj) == D) {
						matrix[toIndex(i,j)].turnOn(toIndex(ii,jj));
					}
				}
			}
		}
	}

	BitSet x;
	return calcEquationSystemMod2(matrix, x) != 0;
}

int main() {
	for (;init();) {
		puts(solve() ? "1" : "0");
	}
	return 0;
}

Measured memory_bytes: 1084