#include<cstdio>

#include<algorithm>

#include<cstring>

#include<cctype>

#include<cstdlib>

#include<queue>

#define maxn 100

#define maxm 100000

#define lim n*m

#define F(i,j) ((i-1)*m+j)

#define T(i,j) (F(i,j)+lim)

using namespace std;

inline long long read(){

    long long num=,f=;

    char ch=getchar();

    while(!isdigit(ch)){

        if(ch=='-')    f=-;

        ch=getchar();

    }

    while(isdigit(ch)){

        num=num*+ch-'';

        ch=getchar();

    }

    return num*f;

}

struct Edge{

    int from,next,to,val,dis,flow;

}edge[maxm];

int head[maxn*maxn],num;

inline void addedge(int from,int to,int val,int dis){

    edge[++num]=(Edge){from,head[from],to,val,dis,};

    head[from]=num;

}

inline void add(int from,int to,int val,int dis){

    addedge(from,to,val,dis);

    addedge(to,from,,-dis);

}

inline int count(int i){    return i&?i+:i-;    }

int dis[maxn*maxn];

int flow[maxn*maxn];

int pre[maxn*maxn];

bool vis[maxn*maxn];

int Start,End;

int n,m;

int spfa(){

    memset(dis,-/,sizeof(dis));    dis[Start]=;    flow[Start]=0x7fffffff;

    queue<int>q;    q.push(Start);

    while(!q.empty()){

        int from=q.front();    q.pop();    vis[from]=;

        for(int i=head[from];i;i=edge[i].next){

            int to=edge[i].to;

            if(edge[i].val<=edge[i].flow||dis[to]>=dis[from]+edge[i].dis)    continue;

            dis[to]=dis[from]+edge[i].dis;

            pre[to]=i;    flow[to]=min(flow[from],edge[i].val-edge[i].flow);

            if(vis[to])    continue;

            vis[to]=;    q.push(to);

        }

    }

    int now=End;

    while(now!=Start){

        int ret=pre[now];

        edge[ret].flow+=flow[End];

        edge[count(ret)].flow-=flow[End];

        now=edge[ret].from;

    }

    return dis[End];

}

struct Node{

    int x,y;

};

Node calc(int ret){

    Node ans;

    ans.x=(ret-)/m+;

    ans.y=ret-(ans.x-)*m;

    return ans;

}

Node q[maxn*maxn];int tot;

void dfs(int x,int y,int now){

    if(now==End)    return;

    for(int i=head[now];i;i=edge[i].next){

        int to=edge[i].to;

        if(edge[i].flow==)    continue;

        edge[i].flow--;    edge[i].val--;

        if(to<=lim)    q[++tot]=calc(to);

        dfs(q[tot].x,q[tot].y,to);

        return;

    }

}

bool ext[maxn][maxn];

int main(){

    int e=read();

    m=read();n=read();

    Start=;    End=n*m*;

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

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

            int x=read();

            if(i!=&&ext[i-][j]==)    add(T(i-,j),F(i,j),0x7fffffff,);

            if(j!=&&ext[i][j-]==)    add(T(i,j-),F(i,j),0x7fffffff,);

            if(x==){

                ext[i][j]=;

                continue;

            }

            add(F(i,j),T(i,j),,x==?:);

            add(F(i,j),T(i,j),0x7fffffff,);

        }

    int cnt=;

    while(){

        int now=spfa();

        if(now<)    break;

        cnt++;

        if(cnt>e)    break;

        tot=;

        dfs(,,);

        q[]=(Node){,};

        for(int j=;j<=tot;++j){

            Node a=q[j-],b=q[j];

            if(a.x==b.x)    printf("%d %d\n",cnt,);

            else            printf("%d %d\n",cnt,);

        }

    }

    return ;

}