// Original C++ solution (slower):
//      whn6325689

//		Mr.Phoebe

//		http://blog.csdn.net/u013007900

#include <algorithm>

#include <iostream>

#include <iomanip>

#include <cstring>

#include <climits>

#include <complex>

#include <fstream>

#include <cassert>

#include <cstdio>

#include <bitset>

#include <vector>

#include <deque>

#include <queue>

#include <stack>

#include <ctime>

#include <set>

#include <map>

#include <cmath>

#include <functional>

#include <numeric>

#pragma comment(linker, "/STACK:1024000000,1024000000")





using namespace std;



typedef long long ll;

typedef long double ld;

typedef pair<ll, ll> pll;

typedef complex<ld> point;

typedef pair<int, int> pii;

typedef pair<pii, int> piii;

typedef vector<int> vi;



#define CLR(x,y) memset(x,y,sizeof(x))

#define mp(x,y) make_pair(x,y)

#define pb(x) push_back(x)

#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))

#define eps 1e-9

#define PI acos(-1.0)

#define INF 0x3f3f3f3f

#define LLINF 1LL<<62



template<class T>

inline bool read(T &n)

{

    T x = 0, tmp = 1;

    char c = getchar();

    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();

    if(c == EOF) return false;

    if(c == '-') c = getchar(), tmp = -1;

    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();

    n = x*tmp;

    return true;

}

template <class T>

inline void write(T n)

{

    if(n < 0)

    {

        putchar('-');

        n = -n;

    }

    int len = 0,data[20];

    while(n)

    {

        data[len++] = n%10;

        n /= 10;

    }

    if(!len) data[len++] = 0;

    while(len--) putchar(data[len]+48);

}

//-----------------------------------



const int MAXN=26*26;



int b[MAXN][MAXN],ans[MAXN];

int a[MAXN][MAXN];



int Guass(int n)

{

	int i,j,p,row=0,col=0;

	for(;row<n&&col<n;row++,col++)

	{

		for(i=row,p=row;i<n;i++)

			if(a[i][col])

			{p=i;break;}

		if(p!=row)

			for(j=col;j<=n;j++)

				swap(a[p][j],a[row][j]);

		if(!a[row][col]) 

		{

			row--;

			continue;

		}

		for(i=row+1;i<n;i++)

			if(a[i][col])

			for(j=col+1;j<=n;j++)

				a[i][j]^=a[row][j];

	}

	for(i=row;i<n;i++)

		if(a[i][n]) return 0;

	return 1;

}



int main()

{

//	freopen("data.txt","r",stdin);

	int n,m,d;

	while(read(m)&&read(n)&&read(d)&&(n+m+d))

	{

		CLR(a,0);

		for(int i=0;i<n;i++)

			for(int j=0;j<m;j++)

				read(b[i][j]);

		for(int i=0;i<n;i++)

			for(int j=0;j<m;j++)

			{

				a[i*m+j][n*m]=b[i][j];

				a[i*m+j][i*m+j]=1;

				for(int x=0;x<n;x++)

					for(int y=0;y<m;y++)

						if(abs(x-i)+abs(y-j)==d)

							a[i*m+j][x*m+y]=1;

			}

		if(Guass(n*m))

			puts("1");

		else

			puts("0");

	}

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cstring>

#include <bitset>

#include <iostream>

#include <cmath>



using namespace std;



int n, m, D;

int a[30][30];

bitset <650> G[650];



inline int id(int x, int y) {

    return x * m + y;

}



bool Gauss(int equ, int var) {

    int col = 0, k;

    for(k = 0; k < equ && col < var; ++k, ++col) {

        if(!G[k][col]) {

            for(int i = k + 1; i < equ; ++i) if(G[i][col]) {

                G[k] ^= G[i];

                break;

            }

        }

        if(!G[k][col]) {

            k--;

            continue;

        }

        for(int i = k + 1; i < equ; ++i) 

			if(G[i][col]) 

				G[i] ^= G[k];

    }

    for(int i = k; i < equ; ++i) 

		if(G[i][var]) 

			return 0;

    return 1;

}



int main() {

    while(scanf("%d%d%d", &m, &n, &D)) {

        if(n == 0) break;

        for(int i = 0; i < n; ++i) 

			for(int j = 0; j < m; ++j) 

				scanf("%d", &a[i][j]);

        int U = n * m;

        for(int i = 0; i < U; ++i) G[i].reset();

        for(int i = 0; i < n; ++i) 

			for(int j = 0; j < m; ++j) {

	            int u = id(i, j);

	            G[u][u] = 1;

	            for(int x = 0; x < n; ++x) 

					for(int y = 0; y < m; ++y) {

		                if(abs(x - i) + abs(y - j) != D) continue;

		                G[id(x, y)][u] = 1;

		            }

        }

        for(int i = 0; i < n; ++i) 

			for(int j = 0; j < m; ++j) {

            if(!a[i][j]) continue;

            G[id(i, j)][n * m] = 1;

        }

        puts(Gauss(n * m, n * m) ? "1" : "0");

    }

    return 0;

}

// Fastest known solution for this problem: