#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_map>
#include<fstream>
#include<list>
#include<typeinfo>
#include<functional>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pi;
typedef pair<double,double> pd;
typedef pair<double,ll> pdl;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;

template<long long int mod=1000000007>
struct Mod_Int{
    typedef long long int ll;
    typedef pair<ll,ll> pll;
    typedef Mod_Int<mod> M;
    ll a;
    
    ll mod_pow(ll a,ll x){
        a%=mod;
        ll ans=1;
        for(int i=0;i<63;i++){
            if(x>>i&1){ans*=a; ans%=mod;}
            a*=a;
            a%=mod;
        }
        return ans;
    }
    
    pll Ex_gcd(ll a,ll b){
        if(b==0){return {1,0};}
        pll ret=Ex_gcd(b,a%b);
        ret.F-=a/b*ret.S;
        return {ret.S,ret.F};
    }
    
    ll prime_R(ll a){
        return mod_pow(a,mod-2);
    }
    
    ll R(ll a){
        ll ret=Ex_gcd(a,mod).F;
        ret%=mod;
        if(ret<0){ret+=mod;}
        return ret;
    }
    
    Mod_Int(ll A=1):a(A){
        a%=mod;
        if(a<0){a+=mod;}
    }
    
    Mod_Int(const M &b):a(b.a){}
    
    M & operator += (const M &b){
        a+=b.a;
        if(a>=mod){a-=mod;}
        return *this;
    }
    
    M operator + (const M &b) const {
        M c=*this;
        return c+=b;
    }
    
    M & operator -= (const M &b){
        a-=b.a;
        if(a<0){a+=mod;}
        return *this;
    }
    
    M operator - (const M &b) const {
        M c=*this;
        return c-=b;
    }
    
    M & operator *= (const M &b){
        (a*=b.a)%=mod;
        return *this;
    }
    
    M operator * (const M &b) const {
        M c=*this;
        return c*=b;
    }
    
    M & operator /= (const M &b){
        (a*=R(b.a))%=mod;
        return *this;
    }
    
    M operator / (const M &b) const {
        M c=*this;
        return c/=b;
    }
    
    M & mod_pow_equal(ll x){
        ll ans=1;
        while(x>0){
            if(x&1){ans*=a; ans%=mod;}
            a*=a;
            a%=mod;
            x>>=1;
        }
        a=ans;
        return *this;
    }
    
    M & mod_pow(ll x){
        M c(a);
        return c.mod_pow_equal(x);
    }
    
    bool operator == (const M &b) const {return a==b.a;}
    
    bool operator != (const M &b) const {return a!=b.a;}
    
    bool operator <= (const M &b) const {return a<=b.a;}
    
    bool operator < (const M &b) const {return a<b.a;}
    
    bool operator > (const M &b) const {return a>b.a;}
    
    bool operator >= (const M &b) const {return a>=b.a;}
    
    M & operator = (const M &b){
        a=b.a;
        return *this;
    }
    
    M & operator = (const ll &b){
        (a=b)%=mod;
        if(a<0){a+=mod;}
        return *this;
    }
};

typedef Mod_Int<2> Int;

/*
 //Mod_Intで行う場合
 //showを使うならそれも変える
 
 const R EPS=0;
 
 inline T fabs(const T &a) const {return a;}
 
 inline bool equals(const R &a,const R &b) const {
 return fabs(a-b)<=EPS;
 }
 */
template<typename T,typename R=double> //要素の型、実数の型 //両方とも実数型を推奨
class Matrix{
private:
    typedef unsigned long ul;
    typedef long long int ll;
    typedef unsigned long long int ull;
    typedef Matrix<T,R> Mat;
    typedef Matrix<R,R> RMat;
    const R EPS=0;
    ul n,m;
    vector<vector<T>> M;
    
    inline T fabs(const T &a) const {return a;}
    
    inline bool equals(const R &a,const R &b) const {
        return fabs(a-b)<=EPS;
    }
    
    //A+=B
    template<typename U>
    vector<U> & pls (vector<U> &A,const vector<U> &B,U a) const {
        assert(A.size()==B.size());
        for(int i=0;i<A.size();i++){
            A[i]+=B[i]*a;
        }
        return A;
    }
    
    //A-=B
    template<typename U>
    vector<U> & mns (vector<U> &A,const vector<U> &B,const U &a) const {
        assert(A.size()==B.size());
        for(int i=0;i<A.size();i++){
            A[i]-=B[i]*a;
        }
        return A;
    }
    
    //A/=b
    template<typename U>
    vector<U> & normalization(vector<U> &A,const U &b) const {
        for(int i=0;i<A.size();i++){
            A[i]/=b;
        }
        return A;
    }
    
    Mat & Row_Permutation(const vector<ul> &P){
        assert(P.size()==n);
        Mat cp=*this;
        for(int i=0;i<n;i++){
            if(P[i]==i){continue;}
            M[i]=cp[P[i]];
        }
        return *this;
    }
    
    Mat & Col_Permutation(const vector<ul> &P){
        assert(P.size()==m);
        Mat cp=*this;
        for(int i=0;i<m;i++){
            if(P[i]==i){continue;}
            for(int t=0;t<n;t++){
                M[t][i]=cp[t][P[i]];
            }
        }
        return *this;
    }
    
    vector<ul> inverseP(const vector<ul> &P) const {
        vector<ul> ret(P.size());
        for(int i=0;i<P.size();i++){
            ret[P[i]]=i;
        }
        return ret;
    }
    
    RMat inverseL(RMat L) const {
        RMat ret; ret=ret.I(L.size());
        for(int i=0;i<L.size();i++){
            R d=L[i][i];
            if(equals(d,0)){return RMat(L.size(),L.size(),0);}
            if(equals(d,1)){continue;}
            ret[i][i]/=d;
            for(int t=0;t<=i;t++){
                L[i][t]/=d;
            }
        }
        for(int i=0;i<L.size();i++){
            for(int t=i+1;t<n;t++){
                if(equals(L.row(t)[i],0)){continue;}
                mns(ret[t],ret[i],L.row(t)[i]);
            }
        }
        return ret;
    }
    
    RMat inverseU(RMat U) const {
        RMat ret; ret=ret.I(U.size());
        for(int i=0;i<U.size();i++){
            R d=U[i][i];
            if(equals(d,0)){return RMat(U.size(),U.size(),0);}
            if(equals(d,1)){continue;}
            ret[i][i]/=d;
            for(int t=i;t<U.size();t++){
                U[i][t]/=d;
            }
        }
        for(ll i=U.size()-1;i>=0;i--){
            for(ll t=i-1;t>=0;t--){
                if(equals(U[t][i],0)){continue;}
                mns(ret[t],ret[i],U[t][i]);
            }
        }
        return ret;
    }
    
public:
    Matrix(const ul &n=0,const ul &m=0,const T &a=T()):n(n),m(m),M(vector<vector<T>>(n,vector<T>(m,a))){}
    
    Matrix(const vector<vector<T>> &M):n(M.size()),m(M[0].size()),M(M){
        for(int i=1;i<M.size();i++){assert(M[i].size()==m);}
    }
    
    /*
     template<typename K,typename L>
     Matrix(const Matrix<K,L> &A):n(A.size()),m(A.csize()),M(vector<vector<T>>(n,vector<T>(m,T()))){
     for(int i=0;i<n;i++){
     for(int t=0;t<m;t++){
     M[i][t]=T(A.row(i)[t]);
     }
     }
     }
     */
    
    vector<T> & operator [] (ul k){
        assert(k<n);
        return M[k];
    }
    
    template<typename K,typename L>
    Mat & operator = (const Matrix<K,L> &A){
        n=A.size(); m=A.csize();
        M.resize(n);
        for(int i=0;i<n;i++){
            M[i].resize(m);
            for(int t=0;t<m;t++){
                M[i][t]=T(A.row(i)[t]);
            }
        }
        return *this;
    }
    
    Mat & operator = (const Mat &A){
        n=A.n; m=A.m;
        M=A.M;
        return *this;
    }
    
    bool operator == (const Mat &A) const {
        return A.M==M;
    }
    
    bool operator != (const Mat &A) const {
        return A.M!=M;
    }
    
    bool operator < (const Mat &A) const {
        if(n<A.n){return true;}
        if(n>A.n){return false;}
        if(m<A.m){return true;}
        if(m>A.m){return false;}
        return M<A.M;
    }
    
    bool operator <= (const Mat &A) const {
        if(n<A.n){return true;}
        if(n>A.n){return false;}
        if(m<A.m){return true;}
        if(m>A.m){return false;}
        return M<=A.M;
    }
    
    bool operator > (const Mat &A) const {
        return A<(*this);
    }
    
    bool operator >= (const Mat &A) const {
        return A<=(*this);
    }
    
    Mat & operator += (const Mat &A){
        assert(n==A.n && m==A.m);
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                M[i][t]+=A[i][t];
            }
        }
        return *this;
    }
    
    Mat operator + (const Mat &A) const {
        Mat ret=*this;
        return ret+=A;
    }
    
    Mat operator += (const T &a){
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                M[i][t]+=a;
            }
        }
        return *this;
    }
    
    Mat operator + (const T &a) const {
        Mat ret=*this;
        return ret+=a;
    }
    
    Mat operator -= (const Mat &A){
        assert(n==A.n && m==A.m);
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                M[i][t]-=A[i][t];
            }
        }
        return *this;
    }
    
    Mat operator - (const Mat &A) const {
        Mat ret=*this;
        return ret-=A;
    }
    
    Mat operator -= (const T &a){
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                M[i][t]-=a;
            }
        }
        return *this;
    }
    
    Mat operator - (const T &a) const {
        Mat ret=*this;
        return ret-=a;
    }
    
    Mat & operator *= (const Mat &B){
        (*this)=(*this)*B;
        return *this;
    }
    
    Mat operator * (const Mat &B) const {
        assert(m==B.n);
        Mat ret(n,B.m);
        for(int i=0;i<n;i++){
            for(int t=0;t<B.m;t++){
                for(int h=0;h<m;h++){
                    ret[i][t]+=M[i][h]*B.row(h)[t];
                }
            }
        }
        return ret;
    }
    
    Mat operator *= (const T &a){
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                M[i][t]*=a;
            }
        }
        return *this;
    }
    
    Mat operator * (const T &a) const {
        Mat ret=*this;
        return ret*=a;
    }
    
    Mat operator /= (const T &a){
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                M[i][t]/=a;
            }
        }
        return *this;
    }
    
    Mat operator / (const T &a) const {
        Mat ret=*this;
        return ret/=a;
    }
    
    Mat operator %= (const T &a){
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                M[i][t]%=a;
            }
        }
        return *this;
    }
    
    Mat operator % (const T &a) const {
        Mat ret=*this;
        return ret%=a;
    }
    
    ul size() const {return n;}
    
    ul csize() const {return m;}
    
    void resize(const ul &x,const ul &y){
        n=x; m=y;
        M.resize(n);
        for(int i=0;i<n;i++){
            M[i].resize(y);
        }
    }
    
    void clear(){
        n=0; m=0;
        M.clear();
    }
    
    const vector<T> & row(ul x) const {
        assert(x<n);
        return M[x];
    }
    
    R det() const {
        //*
        //LUPD
        return LUPD().F.F;
        //*/
        
        /*
         //Gaussian_Elimination
         assert(n==m);
         return Gaussian_Elimination(RMat(n,0)).S;
         //*/
    }
    
    RMat inverse() const {
        //*
        //LUPD
        pair<pair<R,vector<ul>>,pair<RMat,RMat>> ret=LUPD();
        ret.S.F=inverseL(ret.S.F);
        ret.S.S=inverseU(ret.S.S);
        ret.F.S=inverseP(ret.F.S);
        return (ret.S.S*ret.S.F).Col_Permutation(ret.F.S);
        //*/
        
        /*
         //Gaussian_Elimination
         assert(n==m);
         RMat y; y=y.I(n);
         return Gaussian_Elimination(y).F;
         //*/
    }
    
    Mat I(const ul &size) const {
        Mat ret(size,size,(T)0);
        for(int i=0;i<size;i++){
            ret[i][i]=(T)1;
        }
        return ret;
    }
    
    Mat mod_pow(ull x,const T &mod) const {
        assert(n==m);
        Mat ret=I(n);
        Mat A=*this;
        for(ul i=0;i<64;i++){
            if(x&1){ret*=A;}
            x>>=1;
            if(x==0){break;}
            A*=A;
            A%=mod;
        }
        return ret;
    }
    
    RMat equation(const RMat &Y) const {
        return inverse()*Y;
        //return Gaussian_Elimination(Y).F;
    }
    
    pair<RMat,RMat> LUD() const {
        assert(n==m);
        RMat A; A=(*this);
        RMat L; L=L.I(n);
        RMat U(n,n);
        for(int i=0;i<n;i++){
            for(int t=0;t<n;t++){
                for(int h=0;h<min(i,t);h++){
                    A[i][t]-=L[i][h]*U[h][t];
                }
                if(i>t){
                    if(equals(A[i][t],0)){L[i][t]=0;}
                    else{L[i][t]=A[i][t]/U[t][t];}
                }
                else{U[i][t]=A[i][t];}
            }
        }
        return {L,U};
    }
    
    //det,P,L,U
    pair<pair<R,vector<ul>>,pair<RMat,RMat>> LUPD() const {
        assert(n==m);
        RMat A; A=(*this);
        RMat L(n,n,(R)0);
        RMat U; U=U.I(n);
        vector<ul> P(n);
        R det=(R)1;
        for(int i=0;i<n;i++){P[i]=i;}
        for(int i=0;i<n;i++){
            for(int t=i;t<n;t++){
                for(int h=0;h<i;h++){
                    A[t][i]-=L[t][h]*U[h][i];
                }
            }
            R mx=fabs(A[i][i]);
            ll w=i;
            for(int t=i+1;t<n;t++){
                if(mx<fabs(A[t][i])){mx=fabs(A[t][i]); w=t;}
            }
            if(equals(mx,0)){return {{0,P},{RMat(n,n,(R)0),U.I(n)}};}
            if(i!=w){
                det*=(R)-1;
                swap(P[i],P[w]);
                swap(A[i],A[w]);
                swap(L[i],L[w]);
            }
            for(int t=i;t<n;t++){
                L[t][i]=A[t][i];
            }
            det*=L[i][i];
            for(int t=i+1;t<n;t++){
                for(int h=0;h<i;h++){
                    A[i][t]-=L[i][h]*U[h][t];
                }
                U[i][t]=A[i][t]/L[i][i];
            }
        }
        return {{det,P},{L,U}};
    }
    
    pair<RMat,RMat> Gaussian_Elimination(RMat y) const {
        RMat A=*this;
        R k=(R)1;
        for(int i=0;i<n;i++){
            R mx=fabs(A[i][i]);
            ll w=i;
            for(int t=i+1;t<n;t++){
                if(mx<fabs(A[t][i])){mx=fabs(A[t][i]); w=t;}
            }
            if(w!=i){
                swap(A[i],A[w]);
                swap(y[i],y[w]);
                k*=(R)-1;
            }
            R d=A[i][i];
            k*=d;
            if(!equals(d,0)){
                normalization(y[i],d);
                normalization(A[i],d);
                for(int t=0;t<n;t++){
                    if(i==t){continue;}
                    R e=A[t][i];
                    if(equals(e,0)){continue;}
                    mns(y[t],y[i],e);
                    mns(A[t],A[i],e);
                }
            }
            else{
                //return {RMat(y.size(),y.csize(),R(0)),(R)0};
            }
        }
        return {A,y};
    }
    
    void show() const {
        for(int i=0;i<n;i++){
            for(int t=0;t<m;t++){
                if(equals(M[i][t],0)){cout<<0;}
                else{cout<<M[i][t];}
                if(t!=m-1){cout<<" ";}
            }
            cout<<endl;
        }
    }
};

typedef Matrix<Int,Int> M;

    
int main(){
    vector<ll> ans;
    ll h,w,d;
    while(cin>>w>>h>>d && h){
    M m(h*w,h*w+1,0);
    for(int i=0;i<h;i++){
        for(int t=0;t<w;t++){
            for(int x=0;x<h;x++){
                for(int y=0;y<w;y++){
                    if(i==x && t==y){m[i*w+t][x*w+y]=1;}
                    else if(abs(i-x)+abs(t-y)==d){
                        m[i*w+t][x*w+y]=1;
                    }
                }
            }
        }
    }
    M y(h*w,1,0);
    for(int i=0;i<h;i++){
        for(int t=0;t<w;t++){
            ll a;
            cin>>a;
            y[i*w+t][0]=a;
        }
    }
    bool done=true;
        pair<M,M> ret=m.Gaussian_Elimination(y);
    for(int i=0;i<m.size() && done;i++){
        bool none=true;
        for(int t=0;t<m.size() && done;t++){
            if(ret.F[i][t].a){none=false;}
        }
        if(none && ret.S[i][0]!=0){done=false;}
    }
        ans.push_back(done);
        //cout<<done<<endl;
    
    }
    for(int i=0;i<ans.size();i++){
        cout<<ans[i]<<endl;
    }
    
    
    
    
    return 0;
}

