Problem:
散歩
問題
JOI 町に住む太郎君は, ある日,健康増進のために散歩を日課にしようと思い立った.
 太郎君の住む JOI 町には,図のように,東西方向に走る (
H
+ 1) 本の道路と,南北
方向に走る (
W
+ 1) 本の道路が碁盤目状に通っている.太郎君の家はもっとも北西の
交差点にあり,ここから散歩を開始する.
以降,北から
a
番目,西から
b
番目の交差点を (
a
,
b
) で表す.たとえば,太郎君の家がある交差点は (1, 1) である.
図: JOI 町の図 (
H
= 3,
W
= 4 の場合).図の上が北,左が西に対応する.
太郎君は,散歩のルートが日々違ったほうが面白いと考えたので,(1, 1) から (
H
,
W
) までの
H
×
W
個の交差点に, 「東」または「南」の文字を書き,次のようなルールに従って毎日散歩を行うことにした.
文字の書かれた交差点にいる場合,その交差点に書かれている文字が「東」な
  ら「南」に, 「南」なら「東」に文字を書き換え,もともと書かれていた文字の方角にある次の交差点まで進む.
もっとも東やもっとも南の道路に到達したら散歩を終了する.
この計画を考えた後,太郎君は,将来の散歩で自分がどのようなルートをたどる
ことになるのかが気になった.太郎君のために,太郎君の
N
回目の散歩のルートを
予測するプログラムを作成せよ.
入力
入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．
1 行目には,3 つの正整数が空白区切りで書かれている.これらは,問題文中の 3 つの数値
H
,
W
,
N
の値である.
H
,
W
,
N
はそれぞれ, 1 ≤
H
≤ 1000, 1 ≤
W
≤ 1000, 1 ≤
N
≤  10000000 = 10
7
をみたす. 2 行目から
H
+ 1 行目には,それぞれ
W
個の整数が空白区切りで書かれている.これらは,太郎君が最初に交差点に書いた文字の情報を表す.
i
+ 1 行目の
j
番目の整数が 0 なら,交差点 (
i
,
j
) に書かれた文字が「南」であることを, 1 なら, 交差点 (
i
,
j
) に書かれた文字が「東」であることを表す.
採点用データのうち,配点の 30%分については,
H
≤ 100,
W
≤ 100,
N
≤ 1000 を満たす.
H
,
W
,
N
がすべて 0 のとき入力の終了を示す. データセットの数は 10 を超えない．
出力
データセットごとに次の形式で出力する.
N
回目の散歩において太郎君が散歩を終了する交差点が (
i
,
j
) のとき,
i
と
j
をこの順に空白で区切って出力せよ.
入出力の例
入力例
3 4 3
1 0 1 1
0 1 0 0
1 0 1 0
0 0 0
出力例
1 5
上の例では,1 回目から 3 回目の散歩のルートは次の図のようになる.
上記問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

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

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    while (true) {
        int h, w, n;
        cin >> h >> w >> n;
        if (!h && !w && !n) break;  // 終了条件

        // c[y][x]: (y,x) マスに到達するトークン数
        // 入力のマス a を足したり反転判定に使う
        vector<vector<long long>> c(h+1, vector<long long>(w+1, 0));
        int a;
        c[0][0] = n - 1;  // 最初に (0,0) に n−1 個を置く

        // 行 i, 列 j を走査
        for(int i = 0; i < h; i++){
            for(int j = 0; j < w; j++){
                cin >> a;
                long long tok = c[i][j];
                long long half = tok / 2;
                // 均等分配
                c[i+1][j] += half;
                c[i][j+1] += half;
                // 余り1なら a によって振り分け先を決定
                if (tok & 1LL) {
                    if (a) {
                        // a==1 なら下に余り
                        c[i][j+1]++;
                    } else {
                        // a==0 なら右に余り
                        c[i+1][j]++;
                    }
                }
                // c[i][j] に a を「スイッチ」として足す
                c[i][j] += a;
            }
        }

        // 最終的に (0,0) から落ちてくるルートを追跡
        int x = 0, y = 0;
        while (x < w && y < h) {
            // c[y][x] の偶奇で進行方向を決定
            if (c[y][x] & 1LL) {
                x++;
            } else {
                y++;
            }
        }

        // 1-index 出力
        cout << (y + 1) << " " << (x + 1) << "\n";
    }

    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 11248
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(n);i++)

// #include <atcoder/all>
// using namespace atcoder;
// using mint=modint1000000007;

using ll=long long;
using ull=unsigned long long;
using P=pair<int,int>;
using Pl=pair<ll,ll>;
using Pd=pair<double,int>;

const ll ll_INF=1e18;
const int INF=1001001001;
const int di[]={0,1,0,-1};
const int dj[]={1,0,-1,0};

template<class T>
void chmin(T &a, T b) { a=min(a,b); }
template<class T>
void chmax(T &a, T b) { a=max(a,b); }

struct Edge{
    int to; ll cost;
    Edge(){}
    Edge(int to):to(to){};
    Edge(int to, ll cost):to(to),cost(cost){};
};

int main(){
    while(true){
        int h,w,n; cin >> h >> w >> n;
        if(h==0 && w==0 && n==0) break;
        vector direction(h,vector<int>(w));
        REP(i,h)REP(j,w){
            int d; cin >> d;
            direction.at(i).at(j)=d;
        }
        vector dp(h+1,vector<int>(w+1));
        dp.at(0).at(0)=n-1;
        REP(i,h)REP(j,w){
            if(direction.at(i).at(j)){
                dp.at(i).at(j+1)+=(dp.at(i).at(j)+1)/2;
                dp.at(i+1).at(j)+=dp.at(i).at(j)/2;
            } else {
                dp.at(i).at(j+1)+=dp.at(i).at(j)/2;
                dp.at(i+1).at(j)+=(dp.at(i).at(j)+1)/2;
            }
        }

        REP(i,h)REP(j,w){
            if(dp.at(i).at(j)&1) direction.at(i).at(j)^=1;
        }
        int x=0,y=0;
        while(x<h && y<w){
            if(direction.at(x).at(y)) y++;
            else x++;
        }
        cout << x+1 << " " << y+1 << endl;
    }
}
accuracy: 1
time_ms: 110
memory_kb: 10620
final_rank: 13

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

int main() {
    int H,W,N;
    while(cin>>H>>W>>N,H+W+N!=0){
        vector<vector<int>> A(H,vector<int>(W));
        vector<vector<int>> DP(H,vector<int>(W,0));
        DP[0][0]=N-1;
        for(int h=0;h<H;h++)for(int w=0;w<W;w++){
            cin>>A[h][w];
            if(h!=0)DP[h][w]+=(DP[h-1][w]+1-A[h-1][w])/2;
            if(w!=0)DP[h][w]+=(DP[h][w-1]+A[h][w-1])/2;
        }
        for(int h=0;h<H;h++)for(int w=0;w<W;w++)if(DP[h][w]%2)A[h][w]=1-A[h][w];
        int y=0,x=0;
        while(y<H&&x<W){
            if(A[y][x])x++;
            else y++;
        }
        cout<<y+1<<" "<<x+1<<endl;
    }
}
accuracy: 1
time_ms: 100
memory_kb: 10920
final_rank: 11

code_snippet: #include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i,n) for(int i=0;i<(n);i++)
//using mint=modint1000000007;
using ll=long long;
using P=pair<int,int>;
using Pl=pair<ll,ll>;

const int INF=1e9;
const int dx[]={0,1};
const int dy[]={1,0};

struct Edge{
    int to; ll cost;
    Edge(){}
    Edge(int to):to(to){};
    Edge(int to, ll cost):to(to),cost(cost){};
};

int main(){
    while(true){
        int h,w,n; cin >> h >> w >> n;
        if(h==0 && w==0 && n==0) break;
        vector dir(h,vector<int>(w));
        rep(i,h) rep(j,w) cin >> dir[i][j];
        vector dp(h+1,vector<int>(w+1));
        dp[0][0]=n-1;
        rep(i,h) rep(j,w){
            if(dir[i][j]==0){
                dp[i+1][j]+=dp[i][j]-dp[i][j]/2;
                dp[i][j+1]+=dp[i][j]/2;
            } else {
                dp[i+1][j]+=dp[i][j]/2;
                dp[i][j+1]+=dp[i][j]-dp[i][j]/2;
            }
        }
        rep(i,h) rep(j,w) {
            dir[i][j]=(dir[i][j]+dp[i][j]%2)%2;
        }

        int i=0,j=0;
        while(i<h && j<w){
            if(dir[i][j]==0) i++;
            else j++;
        }
        cout << i+1 << " " << j+1 << endl;
    }
}
accuracy: 1
time_ms: 100
memory_kb: 10948
final_rank: 12

code_snippet: #include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i,n) for(int i=0;i<(n);i++)
//using mint=modint1000000007;
using ll=long long;
using P=pair<int,int>;

const int INF=1001001001;
const int dx[]={1,0};
const int dy[]={0,1};

struct Edge{
    int to,cost;
    Edge(){}
    Edge(int to):to(to){};
    Edge(int to, int cost):to(to),cost(cost){};
};

int main(){
    while(true){
        int h,w,n; cin>>h>>w>>n;
        if(h==0 && w==0 && n==0) break;
        vector dir(h,vector<int>(w));
        rep(i,h) rep(j,w) cin>>dir[i][j];
        vector dp(h+1,vector<int>(w+1));
        dp[0][0]=n-1;
        rep(i,h) rep(j,w){
            if(dir[i][j]){
                dp[i+1][j]+=dp[i][j]/2;
                dp[i][j+1]+=dp[i][j]-dp[i][j]/2;
            } else {
                dp[i][j+1]+=dp[i][j]/2;
                dp[i+1][j]+=dp[i][j]-dp[i][j]/2;
            }
        }
        rep(i,h)rep(j,w) dir[i][j]=(dir[i][j]+dp[i][j]%2)%2;
        int i=0,j=0;
        while(i<h && j<w){
            if(dir[i][j]) j++;
            else i++;
        }
        cout << i+1 << " " << j+1 << endl;
    }
}
accuracy: 1
time_ms: 100
memory_kb: 10832
final_rank: 9

code_snippet: #include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i,n) for(int i=0;i<(n);i++)
//using mint=modint1000000007;
using ll=long long;
using P=pair<int,int>;

const int INF=1001001001;
const int dx[]={1,0};
const int dy[]={0,1};

struct Edge{
    int to,cost;
    Edge(){}
    Edge(int to):to(to){};
    Edge(int to, int cost):to(to),cost(cost){};
};

int main(){
    while(true){
        int h,w,n; cin >> h >> w >> n;
        if(h==0 && w==0 && n==0) break;
        vector<vector<int>> dir(h,vector<int>(w));
        rep(i,h) rep(j,w) cin >> dir[i][j];
        vector dp(h+1,vector<int>(w+1));
        dp[0][0]=n-1;
        rep(i,h) rep(j,w){
            int now=dp[i][j];
            if(dir[i][j]) {
                dp[i+1][j]+=now/2;
                dp[i][j+1]+=now-now/2;
            } else {
                dp[i][j+1]+=now/2;
                dp[i+1][j]+=now-now/2;
            }
        }
        rep(i,h) rep(j,w){
            dir[i][j]=(dir[i][j]+dp[i][j]%2)%2;
        }
        // rep(i,h) {
        //     rep(j,w) cout << dir[i][j];
        //     cout << endl;
        // }
        int x=0,y=0;
        while(x<h && y<w){
            if(dir[x][y]) y++;
            else x++;
        }
        cout << x+1 << " " << y+1 << endl;
    }
}
accuracy: 1
time_ms: 100
memory_kb: 10864
final_rank: 10

code_snippet: #include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i,n) for(int i=0;i<(n);i++)
//using mint=modint1000000007;
using ll=long long;
using P=pair<int,int>;

const int INF=1001001001;
const int dx[]={1,0};
const int dy[]={0,1};

struct Edge{
    int to,cost;
    Edge(){}
    Edge(int to):to(to){};
    Edge(int to, int cost):to(to),cost(cost){};
};

int main(){
    while(1){
        int h,w,n; cin >> h >> w >> n;
        if(h==0) break;
        vector d(h,vector<int>(w));
        rep(i,h)rep(j,w) cin >> d[i][j];
        vector dp(h+1,vector<int>(w+1));
        dp[0][0]=n;
        rep(i,h)rep(j,w){
            int m=dp[i][j]/2;
            if(d[i][j]){
                dp[i+1][j]+=m;
                dp[i][j+1]+=dp[i][j]-m;
            } else {
                dp[i][j+1]+=m;
                dp[i+1][j]+=dp[i][j]-m;
            }
        }
        int x=0,y=0;
        while(x<h && y<w){
            //初手東
            if(d[x][y]){
                //dpはn回散歩を行った後の通過回数
                //初手東でdpが奇数ならn回散歩した後は南になった状態
                //つまりn回目は東へ進んだということ
                if(dp[x][y]&1) y++;
                else x++;
            } else {
                if(dp[x][y]&1) x++;
                else y++;
            }
        }
        x++; y++;
        cout << x << ' ' << y << '\n';
    }
}
accuracy: 1
time_ms: 100
memory_kb: 10812
final_rank: 8

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[1001][1001], dp[1001][1001];
int h, w, n;

void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << endl;
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}

int main() {
  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        int half = dp[i][j] / 2;  // Compute half
        int remainder = dp[i][j] % 2;  // Compute remainder
        dp[i][j + 1] += half + mp[i][j] * remainder;
        dp[i + 1][j] += half + !mp[i][j] * remainder;
        if (remainder)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 140
memory_kb: 10924
final_rank: 18

code_snippet: #include <iostream>
#include <cstring>
using namespace std;

int mp[1001][1001], dp[1001][1001];
int h, w, n;

void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << '\n';
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);

  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        dp[i][j + 1] += dp[i][j] / 2 + mp[i][j] * dp[i][j] % 2;
        dp[i + 1][j] += dp[i][j] / 2 + !mp[i][j] * dp[i][j] % 2;
        if (dp[i][j] % 2)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }

  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 11184
final_rank: 7

code_snippet: #include <iostream>
#include <cstring>
#define MAX_SIZE 1001

int mp[MAX_SIZE][MAX_SIZE], dp[MAX_SIZE][MAX_SIZE];
int h, w, n;

void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    std::cout << y + 1 << " " << x + 1 << '\n';
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}

int main() {
  std::ios_base::sync_with_stdio(false); 
  std::cin.tie(NULL);
  while (1) {
    std::cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        std::cin >> mp[i][j];
    std::memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        dp[i][j + 1] += dp[i][j] / 2 + mp[i][j] * dp[i][j] % 2;
        dp[i + 1][j] += dp[i][j] / 2 + !mp[i][j] * dp[i][j] % 2;
        if (dp[i][j] % 2)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 10996
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[1001][1001], dp[1001][1001];
int h, w, n;
void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << endl;
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}
int main() {
  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        dp[i][j + 1] += dp[i][j] / 2 + mp[i][j] * dp[i][j] % 2;
        dp[i + 1][j] += dp[i][j] / 2 + !mp[i][j] * dp[i][j] % 2;
        if (dp[i][j] % 2)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 140
memory_kb: 10876
final_rank: 17

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[1001][1001], dp[1001][1001];
;
int h, w, n;
void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << endl;
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}
int main() {
  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        dp[i][j + 1] += dp[i][j] / 2 + mp[i][j] * dp[i][j] % 2;
        dp[i + 1][j] += dp[i][j] / 2 + !mp[i][j] * dp[i][j] % 2;
        if (dp[i][j] % 2)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 140
memory_kb: 10824
final_rank: 15

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[1001][1001], dp[1001][1001];
;
int h, w, n;
void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << endl;
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}
int main() {
  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        dp[i][j + 1] += dp[i][j] / 2 + mp[i][j] * dp[i][j] % 2;
        dp[i + 1][j] += dp[i][j] / 2 + !mp[i][j] * dp[i][j] % 2;
        if (dp[i][j] & 1)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 140
memory_kb: 10824
final_rank: 15

code_snippet: #include <bits/stdc++.h>
using namespace std;
const int MAX = 1001;
int mp[MAX][MAX], dp[MAX][MAX];
int h, w, n;
void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << endl;
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        int x = dp[i][j] / 2;
        dp[i][j + 1] += x + mp[i][j] * (dp[i][j] & 1);
        dp[i + 1][j] += x + !mp[i][j] * (dp[i][j] & 1);
        if (dp[i][j] & 1)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 10960
final_rank: 5

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[1001][1001], dp[1001][1001];
int h, w, n;
void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << endl;
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  while (cin >> h >> w >> n, h || w || n) {
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        int half = dp[i][j] / 2, odd = dp[i][j] % 2;
        dp[i][j + 1] += half + mp[i][j] * odd;
        dp[i + 1][j] += half + !mp[i][j] * odd;
        if (odd)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 10936
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[1001][1001], dp[1001][1001];
int h, w, n;
void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  while (y != h && x != w) {
    int nx = x + dx[mp[y][x]];
    int ny = y + dy[mp[y][x]];
    x = nx;
    y = ny;
  }
  cout << y + 1 << " " << x + 1 << endl;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        int t = dp[i][j] % 2;
        dp[i][j + 1] += dp[i][j] / 2 + mp[i][j] * t;
        dp[i + 1][j] += dp[i][j] / 2 + !mp[i][j] * t;
        if (t)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 10936
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[1001][1001], dp[1001][1001];
int h, w, n;
void saiki(int x, int y) {
  int dx[] = {0, 1}, dy[] = {1, 0};
  if (y == h || x == w)
    cout << y + 1 << " " << x + 1 << endl;
  else
    saiki(x + dx[mp[y][x]], y + dy[mp[y][x]]);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  while (1) {
    cin >> h >> w >> n;
    if (!h && !w && !n)
      break;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++)
        cin >> mp[i][j];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = n - 1;
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        int t1 = dp[i][j] / 2 + mp[i][j] * dp[i][j] % 2;
        int t2 = dp[i][j] / 2 + !mp[i][j] * dp[i][j] % 2;
        dp[i][j + 1] += t1;
        dp[i + 1][j] += t2;
        if (dp[i][j] % 2)
          mp[i][j] = !mp[i][j];
      }
    saiki(0, 0);
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 10956
final_rank: 4

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
using pl = pair<ll,ll>;
using vp = vector<pl>;
#define rep(i,n) for(ll i=0;i<(ll)(n);++i)
#define reps(i,s,n) for(ll i=(s);i<(ll)(n);++i)
#define rep1(i,n) for(ll i=1;i<=(ll)(n);++i)
template<typename T>inline bool chmax(T &a,T b){return a<b?a=b,true:false;}
template<typename T>inline bool chmin(T &a,T b){return a>b?a=b,true:false;}
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define be(v) (v).begin(),(v).end()
const long long INF = 1e18;
inline ll ipow(ll x,ll p){
	ll ret=x; rep1(i,p-1) ret*=x; return ret;
}
#ifdef DEBUG
#include <debug.hpp>
#endif

bool  solve(){
#ifdef DEBUG
	cout << "--- Input ---" << endl;
#endif
	ll H,W,N;cin>>H>>W>>N;
	if(H==0 && W==0 && N==0)return false;
	vvl A(H,vl(W,0));
	rep(h,H)rep(w,W)cin>>A.at(h).at(w);
#ifdef DEBUG
	cout<<H<<" "<<W<<" "<<N<<endl<<A;
	cout << "--- Logic ---" << endl;
#endif
	vvl dp(H,vl(W,0));
	dp.at(0).at(0)=N-1;
	rep(h,H)rep(w,W){
		if(h-1>=0){
			dp.at(h).at(w)+=dp.at(h-1).at(w)/2;
			if(dp.at(h-1).at(w)%2 && !A.at(h-1).at(w))
				dp.at(h).at(w)+=1;
		}
		if(w-1>=0){
			dp.at(h).at(w)+=dp.at(h).at(w-1)/2;
			if(dp.at(h).at(w-1)%2 && A.at(h).at(w-1))
				dp.at(h).at(w)+=1;
		}
	}
#ifdef DEBUG
	cout<<dp;
#endif
	ll ih=0,iw=0;
	while(ih<H && iw<W){
		if(dp.at(ih).at(iw)%2 && A.at(ih).at(iw)) ++ih;
		else if(dp.at(ih).at(iw)%2 && !A.at(ih).at(iw)) ++iw;
		else if(!(dp.at(ih).at(iw)%2) && A.at(ih).at(iw)) ++iw;
		else if(!(dp.at(ih).at(iw)%2) && !A.at(ih).at(iw)) ++ih;
#ifdef DEBUG
		cout<<"ih="<<ih<<" iw="<<iw<<endl;
#endif
	}
#ifdef DEBUG
	cout << "--- Answer ---" << endl;
#endif
	cout<<ih+1<<" "<<iw+1<<endl;
	return true;
}
int main(){
	while(solve());
	return 0;
}
//cout << fixed << setprecision(9);
accuracy: 1
time_ms: 100
memory_kb: 18604
final_rank: 20

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <random>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)

template<class T>
using vi = vector<T>;

template<class T>
using vii = vector<vi<T>>;

template<class T>
using viii = vector<vii<T>>;

int main()
{
    int h, w, n;
    while(cin >> h >> w >> n, h + w + n){
        vii<int> d(h, vi<int>(w));
        rep(i, h) rep(j, w) cin >> d[i][j];
    
        vii<int> dp(h, vi<int>(w));
        dp[0][0] = n - 1;
    
        const int dx[2] = { 1, 0 };
        const int dy[2] = { 0, 1 };
        
        for (int i = 0; i < h + w; i++) {
            for (int j = 0; j <= i; j++) {
                int x = i - j;
                int y = j;
                if (x < 0 || x >= h || y < 0 || y >= w) continue;
                rep(k, 2) {
                    int nx = x + dx[k];
                    int ny = y + dy[k];
                    if (nx >= h || ny >= w) continue;
                    if (k == d[x][y]) dp[nx][ny] += (dp[x][y] + 1) / 2;
                    else dp[nx][ny] += dp[x][y] / 2;
                }
                if (dp[x][y] % 2) d[x][y] = 1 - d[x][y];
            }
        }
        
        {
            int sx = 0, sy = 0;
            while (sx < h && sy < w) {
                int nx = sx + dx[d[sx][sy]];
                int ny = sy + dy[d[sx][sy]];
                sx = nx, sy = ny;
            }
            sx++, sy++;
            cout << sx << ' ' << sy << endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 10812
final_rank: 14

code_snippet: #include "bits/stdc++.h"

#define REP(i,num) for(ll i=0;i<(num);++i)
#define FOR(i,c,num) for(ll (i)=(c);(i)<(num);++(i))
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}

using namespace std;
using ll = long long;
using ull = unsigned long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;

constexpr ll atcoder_mod = 1e9+7;

template<typename T=ll>
T in(){ T x; cin >> x; return (x); }
template<typename T=ll,typename C=vector<T>>
C vecin(int N){ C x(N);REP(i,N){ x[i]=in<T>(); }return x; }
template<typename T=ll,size_t N>
array<T,N> arrin(){array<T,N> x;REP(i,N){ x[i]=in<T>(); }return x;}

void vout(){ cout << endl; }
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){ cout << ' ' << h;vout(forward<Tail>(t)...); }
void out(){ cout << endl; }
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){ cout << h;vout(forward<Tail>(t)...); }

template<typename T>
bool chmax(T& a,T b){ if(a<b){ a=b;return true; }return false; }
template<typename T>
bool chmin(T& a,T b){ if(a>b){ a=b;return true; }return false; }

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);

	while(true){
		ll H=in(),W=in(),N=in();
		if(!H && !W && !N) break;

		vvll S(H,vll(W)),C(H+1,vll(W+1,0));
		REP(i,H){
			REP(j,W){
				S[i][j]=in();
			}
		}
		C[0][0]=N;

		REP(v,H){
			REP(u,W){
				ll R=C[v][u]/2;
				if(S[v][u]){
					C[v+1][u] += R;
					C[v][u+1] += C[v][u]-R;
				}
				else{
					C[v][u+1] += R;
					C[v+1][u] += C[v][u]-R;
				}
			}
		}

		ll x=0,y=0;
		while(x<W && y<H){
			if(S[y][x]){
				if(C[y][x]%2){
					x++;
				}
				else{
					y++;
				}
			}
			else{
				if(C[y][x]%2){
					y++;
				}
				else{
					x++;
				}
			}
		}
		out(y+1,x+1);
	}
	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 18692
final_rank: 19