#include<bits/stdc++.h>
using namespace std;
const int nmax=1e3+42,TL=4.5;
int n,m,mx,t;
int inp[nmax][nmax];
bool been[nmax][nmax];

vector< pair<int,int> > path,best_now,output;

int score=0;

void print()
{
    //printf("%i\n",score);
    if(output.size()==0)output=best_now;

    printf("%i\n",output.size());

    for(auto k:output)
        printf("%i %i\n",k.first,k.second);
    exit(0);
}

int x_[4]={1,-1,0,0};
int y_[4]={0,0,-1,1};

bool free(int x,int y)
{
    if(1>x||x>n||1>y||y>m)return 0;
    if(been[x][y])return 0;
    if(inp[x][y]==-1)return 0;
    return 1;
}

vector< pair<int,int> > adj[nmax][nmax];

int gain[5]={0,5,4,3,2}/*{0,1,5,4,3}*//*{0,1,2,3,4}*/;

int eval(pair<int,int> a)
{
    int ret=0;
    for(int i=0;i<4;i++)
        if(free(a.first+x_[i],a.second+y_[i]))ret++;
    return ret;
}
bool cmp(pair<int,int> a,pair<int,int> b)
{
    return gain[eval(a)]>gain[eval(b)];
}

int when=0;

void dfs(int x,int y)
{
    when=(when+1)%10000;
    if(when==0)
    {
        if(1.0*(clock()-t)/CLOCKS_PER_SEC>TL)print();
    }
    //cout<<"dfs "<<x<<" "<<y<<endl;
    if(free(x,y)==0)return;

    been[x][y]=1;

    path.push_back({x,y});

    if(path.size()==mx)
    {
        best_now=path;
        path.pop_back();
        return;
    }
    /*
    for(int i=0;i<4;i++)
    {
        dfs(x+x_[i],y+y_[i]);
    }
    */
    adj[x][y]={};
    for(int i=0;i<4;i++)
        if(free(x+x_[i],y+y_[i]))
            adj[x][y].push_back({x+x_[i],y+y_[i]});

    sort(adj[x][y].begin(),adj[x][y].end(),cmp);
    for(auto k:adj[x][y])
        dfs(k.first,k.second);


    if(path.size()>best_now.size())
    {
        best_now=path;
    }

    path.pop_back();
}






const int LIM=(1<<20)+42;

int tree[LIM],dp[LIM];
void build(int node,int l,int r)
{
    if(l==r)
    {
        tree[node]=0;
        return;
    }
    int av=(l+r)/2;
    build(node*2,l,av);
    build(node*2+1,av+1,r);
    tree[node]=0;
}
int query(int node,int l,int r,int lq,int rq)
{
    if(l==lq&&r==rq)return tree[node];
    int av=(l+r)/2,ret=0;
    if(lq<=av)ret=max(ret,query(node*2,l,av,lq,min(av,rq)));
    if(av<rq)ret=max(ret,query(node*2+1,av+1,r,max(av+1,lq),rq));
    return ret;
}
void update(int node,int l,int r,int pos,int val)
{
    if(l==r)
    {
        tree[node]=val;
        return;
    }
    int av=(l+r)/2;
    if(pos<=av)update(node*2,l,av,pos,val);
    else update(node*2+1,av+1,r,pos,val);
    tree[node]=max(tree[node*2],tree[node*2+1]);
}
int solve(vector<int> now)
{
    //for(auto k:now)cout<<k<<" ";cout<<endl;
    int SZ=now.size();
    build(1,0,SZ);

    int mx=0;
    for(int i=0;i<SZ;i++)
    {
        int v=0;
        if(now[i])v=query(1,0,SZ,0,now[i]-1);
        v++;

        dp[i]=v;
        update(1,0,SZ,now[i],dp[i]);
        mx=max(mx,dp[i]);
        //cout<<i<<" -> "<<dp[i]<<endl;
    }
    //cout<<"mx= "<<mx<<endl;
    return mx;
}
int evaluate(vector<int> work)
{
    //for(auto k:inp)cout<<k<<" ";cout<<endl;

    int SZ=work.size();
    vector<int> help=work;
    sort(help.begin(),help.end());

    for(int i=0;i<SZ;i++)
        work[i]=lower_bound(help.begin(),help.end(),work[i])-help.begin();

    int ans=solve(work);
    for(int i=0;i<SZ;i++)
        work[i]=SZ-work[i];

    ans=ans*solve(work);
    return ans;
}











void small()
{
    vector< pair<int,int> > order={};
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        if(free(i,j))
        {
        order.push_back({i,j});
        //if(order.size()==1)i=n,j=m;//remove this
        }
    random_shuffle(order.begin(),order.end());

    for(auto k:order)
    {
        //cout<<"begin "<<k.first<<" "<<k.second<<endl;

        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
            been[i][j]=0;
        best_now={};

        dfs(k.first,k.second);

        vector<int> v={};
        for(auto p:best_now)
            v.push_back(inp[p.first][p.second]);

        int score_now=evaluate(v);

        if(score_now>score)
        {
            score=score_now;
            output=best_now;
        }
    }

    print();
}


int dp_up[nmax],dp_down[nmax];

bitset<21> mem[102][102][102][21];

void dfs_smallest(int x,int y,int lis,int lds,int sz)
{
    //cout<<"dfs_smallest "<<x<<" "<<y<<" "<<lis<<" "<<lds<<" "<<sz<<endl;
    /*
    cout<<"\t";for(auto k:path)cout<<k.first<<" "<<k.second<<", ";cout<<endl;
    cout<<"\t";for(int i=0;i<sz;i++)cout<<dp_up[i]<<" ";cout<<endl;
    cout<<"\t";for(int i=0;i<sz;i++)cout<<dp_down[i]<<" ";cout<<endl;
    */
    /*
    cout<<sz<<" "<<path.size()<<endl;
    for(auto k:path)cout<<k.first<<" "<<k.second<<", ";cout<<endl;
    */
    when=(when+1)%10000;
    if(when==0)
    {
        if(1.0*(clock()-t)/CLOCKS_PER_SEC>TL)print();
    }


    if(free(x,y)==0)
    {
    return;
    }
    path.push_back({x,y});
    been[x][y]=1;

    dp_up[sz]=0;
    for(int i=0;i<sz;i++)
        if(inp[path[i].first][path[i].second]<inp[x][y])dp_up[sz]=max(dp_up[sz],dp_up[i]);

    dp_up[sz]++;

    lis=max(lis,dp_up[sz]);

    dp_down[sz]=0;
    for(int i=0;i<sz;i++)
        if(inp[path[i].first][path[i].second]>inp[x][y])dp_down[sz]=max(dp_down[sz],dp_down[i]);

    dp_down[sz]++;

    lds=max(lds,dp_down[sz]);

    if(lis*lds>score)
    {
        score=lis*lds;
        //cout<<"LIS= "<<lis<<" LDS= "<<lds<<endl;
        output=path;
    }

    if(sz==mx-1)
    {
        path.pop_back();
        been[x][y]=0;
        return;
    }

    if(mem[sz][lis][lds][x][y])
    {
        path.pop_back();
        been[x][y]=0;
        return;
    }
    mem[sz][lis][lds][x][y]=1;

    for(int i=0;i<4;i++)
        if(free(x+x_[i],y+y_[i]))dfs_smallest(x+x_[i],y+y_[i],lis,lds,sz+1);

    path.pop_back();

    been[x][y]=0;
}
void smallest()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
        dfs_smallest(i,j,0,0,0);
        path={};
        }
    print();
}

int main()
{

freopen("path.in","r",stdin);
freopen("path.out","w",stdout);

t=clock();
scanf("%i%i",&n,&m);

for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    scanf("%i",&inp[i][j]);

scanf("%i",&mx);

if(n<=20&&m<=20)
    smallest();

if(n<=100&&m<=100)
    small();

for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
        if(been[i][j]==0)
        {
            dfs(i,j);
        }

print();
return 0;
}