#include <tuple>
#include <queue>
#include <vector>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <deque>
#include <fstream>
#define this (*this)
#define null nullptr
#define EVAL

namespace alex
{
    template <typename T> inline T* malloc(int count)
    {
        void* rt=std::malloc(sizeof(T)*count);
        return (T*)rt;
    }

    template <typename T> using ptr=T*;
    template <typename T> using ref=T&;
    template <typename T> using cref=const T&;
    template <typename T> using cptr=const T*;

    using uint64=uint_fast64_t;
    using uint32=uint_fast32_t;
    using int64=int_fast64_t;
    using int32=int_fast32_t;
    using mdouble=long double;

    template<typename... T> using list=std::vector<T...>;
    template<typename... T> using deque=std::deque<T...>;

    #ifndef EVAL
    auto& cin=std::cin;
    auto& cout=std::cout;
    #else
    std::ifstream cin;
    std::ofstream cout;
    #endif

    char init()
    {
        cin.open("queens.in");
        cout.open("queens.out");
        return '\n';
    }
    const char endl=init();
}

namespace queens
{
    using namespace alex;

    struct point
    {
        int x, y;
        inline point(){}
        inline point(int x, int y){this.x=x;this.y=y;}
    };

    int N, R, K;
    ptr<ptr<int>> Table;

    int newFights(cref<list<list<bool>>> used, cref<point> pt)
    {
        int rt=0;
        for(int i=1;i<=R;i++)
        {
            if(pt.x-i>=0)
            {
                if(used[pt.x-i][pt.y])rt++;

                if(pt.y-i>=0)
                {
                    if(used[pt.x-i][pt.y-i])rt++;
                }
                if(pt.y+i<N)
                {
                    if(used[pt.x-i][pt.y+i])rt++;
                }
            }
            if(pt.x+i<N)
            {
                if(used[pt.x+i][pt.y])rt++;

                if(pt.y-i>=0)
                {
                    if(used[pt.x+i][pt.y-i])rt++;
                }
                if(pt.y+i<N)
                {
                    if(used[pt.x+i][pt.y+i])rt++;
                }
            }
            if(pt.y-i>=0)
            {
                if(used[pt.x][pt.y-i])rt++;
            }
            if(pt.y+i<N)
            {
                if(used[pt.x][pt.y+i])rt++;
            }
        }
        return rt;
    }

    namespace greedy
    {
        inline bool priority (cref<point> a, cref<point> b)
        {
            return Table[a.x][a.y]>Table[b.x][b.y];
        }

        list<point> solve()
        {
            list<point> points;
            for(int i=0;i<N;i++)
            {
                for(int j=0;j<N;j++)points.emplace_back(i, j);
            }

            sort(points.begin(), points.end(), priority);

            //for(auto i : points)cout<<i.x<<' '<<i.y<<endl;

            list<point> rt;
            list<list<bool>> used(N, list<bool>(N, false));
            int fights=0;
            for(cref<point>pt : points)
            {
                int nf=newFights(used, pt);
                if(fights+nf<=K)
                {
                    fights+=nf;
                    used[pt.x][pt.y]=true;
                    rt.push_back(pt);
                }
            }

            return rt;
        }
    }
}

void read()
{
    using namespace queens;
    using namespace alex;

    std::ios::sync_with_stdio(false);
    cin.tie(null); cout.tie(null);

    cin>>N>>R>>K;
    Table=(int**)malloc<int*>(N);
    for(register int i=0, j;i<N;i++)
    {
        Table[i]=malloc<int>(N);
        for(j=0;j<N;j++)cin>>Table[i][j];
    }
}


int main()
{
    using namespace queens;
    using namespace alex;
    read();

    list<point> sol1=greedy::solve();
    for(auto p : sol1)cout<<p.x+1<<' '<<p.y+1<<endl;

}
#undef null
#undef this

#if true==false
6 3 6
2 4 7 5 2 5
7 7 3 1 2 2
2 4 2 4 4 7
4 5 8 5 7 2
5 7 6 5 7 8
8 7 4 3 6 1
#endif // true