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

// 0 or 1 の世界の連立方程式ということはわかるが、これを実装するということか。。。

using D = double;
const D EPS = 1e-10;

// matrix
template <class T>
struct Matrix
{
    vector<vector<T>> val;
    Matrix(int n, int m, T x = 0) : val(n, vector<T>(m, x)) {}
    void init(int n, int m, T x = 0) { val.assign(n, vector<T>(m, x)); }
    size_t size() const { return val.size(); }
    inline vector<T> &operator[](int i) { return val[i]; } // Matrix[][]でアクセスするため。
};

template <class T>
int GaussJordan(Matrix<T> &A, bool is_extended = false)
{
    int m = A.size(), n = A[0].size();
    int rank = 0;
    for (int col = 0; col < n; ++col)
    {
        // 拡大係数行列の場合は最後の列は掃き出ししない
        if (is_extended && col == n - 1)
            break;

        // ピボットを探す
        int pivot = -1;
        T ma = EPS;
        for (int row = rank; row < m; ++row)
        {
            if (abs(A[row][col]) > ma)
            {
                ma = abs(A[row][col]);
                pivot = row;
            }
        }
        // ピボットがなかったら次の列へ
        if (pivot == -1)
            continue;

        // まずは行を swap
        swap(A[pivot], A[rank]);

        // // ピボットの値を 1 にする // 2進法なら不要
        // auto fac = A[rank][col];
        // for (int col2 = 0; col2 < n; ++col2)
        //     A[rank][col2] /= fac;

        // ピボットのある列の値がすべて 0 になるように掃き出す
        for (int row = 0; row < m; ++row)
        {
            if (row != rank && abs(A[row][col]) > EPS)
            {
                //auto fac = A[row][col];// 2進法なら不要
                for (int col2 = 0; col2 < n; ++col2)
                {
                    A[row][col2] -= A[rank][col2];// * fac; // 2進法ならfac不要
                    if (A[row][col2] == -1) A[row][col2] = 1; // 2進法
                }
            }
        }
        ++rank;
    }
    return rank;
}

template <class T>
vector<T> linear_equation(Matrix<T> A, vector<T> b)
{
    // extended
    int m = A.size(), n = A[0].size();
    Matrix<T> M(m, n + 1);
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < n; ++j)
            M[i][j] = A[i][j];
        M[i][n] = b[i];
    }
    int rank = GaussJordan(M, true);

    // check if it has no solution
    vector<T> res;
    for (int row = rank; row < m; ++row)
    {
        if (abs(M[row][n]) > EPS)
        {
            return res;
        }
    }

    // answer
    res.assign(n, 0);
    for (int i = 0; i < rank; ++i)
        res[i] = M[i][n];

    return res;
}

int main(void)
{  
    vector<int> answer;
    while (1)
    {
        int m, n, d;
        cin >> m >> n >> d;
        if (0 == m + n + d)
        {
            break;
        }
        Matrix<int> mat(n * m, n * m);
        vector<int> vec(n * m);
        for (int j = 0; j < n; j++)
        {
            for (int i = 0; i < m; i++)
            {
                cin >> vec[i + (j * m)];
                //vec[i + (j * m)] = 1 - vec[i + (j * m)];
                mat[i + (j * m)][i + (j * m)] = 1;
                for (int k = 0; k < m; ++k) {
                    for (int l = 0; l < n; ++l) {
                        if (abs(i - k) + abs(j - l) != d) continue;
                        mat[i + (j * m)][k + (l * m)] = 1;
                    }
                }
            }
        }

        auto ans = linear_equation(mat, vec);

        answer.push_back((0 == ans.size())?0:1);
    }

    for (auto i = answer.begin(); i < answer.end(); i++)
    {
        cout << *i << endl;
    } 

    return 0;
}


Measured memory_bytes: 7620