using System;
using System.Collections.Generic;


namespace Ice
{
	class Program{
		class Edge{
			public int node;
			public int id;
			
			public Edge(int node, int id){
				this.node = node;
				this.id = id;
			}
		}
		struct Graph{
			public int am_nodes;
			public List<Edge>[] nodes;
			public Graph(int am_nodes){
				this.am_nodes = am_nodes;
				nodes = new List<Edge>[am_nodes];
				for(int i=0;i<am_nodes;i++){
					nodes[i] = new List<Edge>();
				}
			}
		}
		//This was necessary, because tuples are not allowed
		struct GraphWeights{
			public Graph g;
			public int[] w;
		}
		//This was necessary, because tuples are not allowed
		struct EdgeNode{
			public Edge e;
			public int n;
		}
		//This was necessary, because tuples are not allowed
		struct GraphWeightsFlow{
			public GraphWeights gw;
			public int flow;
		}
		static void BFS(bool[] visited,Graph g,int[] w,EdgeNode[] parent,int s,int t){
			visited[s] = true;
			
			//s has no parent
			parent[s].n = -1;
			parent[t].n = -1;

			Queue<int> queue = new Queue<int>();
			queue.Enqueue(s);
			while(queue.Count!=0){
				int u = queue.Dequeue();
				foreach(Edge e in g.nodes[u]){
					int v = e.node;
					if(w[e.id]>0&&!visited[v]){
						parent[v].e=e;
						parent[v].n=u;
						if(v==t)return;

						visited[v] = true;
						queue.Enqueue(v);
					}
				}
			}
		}
		static void DFS(bool[] visited,Graph g,int[] w,int a){
			visited[a] = true;
			foreach(Edge e in g.nodes[a]){
				if(w[e.id]>0&&!visited[e.node]){
					DFS(visited, g,w, e.node);
				}
			}
		}
		static GraphWeights residualGraph(Graph G, int[] c, int[] f){
			int am_edges = c.Length;
			
			//The weights of the residualGraph
			int[] c_f =new int[2*am_edges];
			Graph G_f = new Graph(G.am_nodes);


			for(int i=0;i<am_edges;i++){
				c_f[i] = c[i]-f[i];//weight for the forward arc
				c_f[i+am_edges] = f[i];//weight for the backward arc
			}
			for(int i=0;i<G.am_nodes;i++){
				foreach(Edge e in G.nodes[i]){
					//forward arc
					G_f.nodes[i].Add(e);
					//backward arc
					G_f.nodes[e.node].Add(new Edge(i,e.id+am_edges));
				}
			}
			GraphWeights gw;
			gw.g= G_f;
			gw.w= c_f;
			return gw;
		}
		static GraphWeightsFlow EdmondsKarp(Graph G,int[] c, int s, int t){
			int[] f = new int[c.Length];
			GraphWeights gw = residualGraph(G, c,f);
			Graph G_f = gw.g;
			int[] c_f = gw.w;
			while(true){

				bool[] visited =new bool[G_f.am_nodes];
				EdgeNode[] parent =new EdgeNode[G_f.am_nodes];
				
				BFS(visited,G_f,c_f,parent,s,t);
				if(parent[t].n==-1)break;
	
				int x = Int32.MaxValue;
				for(EdgeNode en = parent[t];en.n!=-1; en=parent[en.n]){
					x = Math.Min(x,c_f[en.e.id]);
				}
				for(EdgeNode en = parent[t];en.n!=-1; en=parent[en.n]){
					if(en.e.id<c.Length){//forward arc
						f[en.e.id]+=x;
						c_f[en.e.id]-=x;
						c_f[en.e.id+c.Length]+=x;
					}else{
						f[en.e.id-c.Length] = f[en.e.id-c.Length] - x;
						c_f[en.e.id-c.Length]-=x;
						c_f[en.e.id]+=x;
					}
				}
			}
			int sum=0;
			foreach(Edge e in G.nodes[s]){
				sum+=f[e.id];
			}
			GraphWeightsFlow gwf;
			gwf.flow = sum;
			gwf.gw = gw;
			return(gwf);
		}
		static void Main(){
			int rows = Int32.Parse(Console.ReadLine());
			int columns = Int32.Parse(Console.ReadLine());
			int mode = Int32.Parse(Console.ReadLine());
			
			int[,] d = new int[columns,rows];
			for(int y =0;y<rows;y++){
			        String[] rowstring = Console.ReadLine().Split();
			        for(int x=0;x<columns;x++){
			    	    d[x,y] = Int32.Parse(rowstring[x]);
			        }
			}
			Graph G = new Graph(rows*columns+2);
			List<int> c = new List<int>();
			int id =0;

			for(int x=0;x<columns;x++){
				for(int y=0;y<rows;y++){
					//From s to a coordinate
					G.nodes[0].Add(new Edge(y*columns+x+1,id));
					c.Add(d[x,y]);
					id++;
					//From a coordinate to t
					G.nodes[y*columns+x+1].Add(new Edge(G.am_nodes-1,id));
					c.Add(32-d[x,y]);
					id++;
					//From a coordinate to a neighbouring coordinate
					int[] neigboursX = {x+1,x+1,x,x-1,x-1,x-1,x,x+1};
					int[] neigboursY = {y,y+1,y+1,y+1,y,y-1,y-1,y-1};
					for(int i=0;i<8;i++){
						int x_2 = neigboursX[i];
						int y_2 = neigboursY[i];
						if(0<=x_2 && x_2<columns&& 0<=y_2 && y_2<rows){
							G.nodes[y*columns+x+1].
								Add(new Edge(y_2*columns+x_2+1,id));
							c.Add(32-Math.Abs(d[x,y]-d[x_2,y_2]));
							id++;
						}
					}
				}
			}
			GraphWeightsFlow gwf = EdmondsKarp(G,c.ToArray(),0,G.am_nodes-1);
			Console.WriteLine(gwf.flow);
			bool[] visited = new bool[rows*columns+2];
			EdgeNode[] parent = new EdgeNode[rows*columns+2];
			BFS(visited, gwf.gw.g, gwf.gw.w, parent, 0, rows*columns+1);
			for(int i=1;i<rows*columns+1;i++){
				if(visited[i]){
					Console.WriteLine($"{(i-1)/columns} {(i-1)%columns}");
				}
			}

			//https://www.youtube.com/watch?v=Tl90tNtKvxs&t=193s time 4:33
			//0: S, 1:A, 2:B, 3:C, 4:D, 5:T
			//Graph g = new Graph(6);
			//int[] c = {10,10,4,2,6,10,9,6,10};
			//g.nodes[0].Add(new Edge(1,0));
			//g.nodes[0].Add(new Edge(3,1));
			//g.nodes[1].Add(new Edge(2,2));
			//g.nodes[1].Add(new Edge(3,3));
			//g.nodes[1].Add(new Edge(4,4));
			//g.nodes[2].Add(new Edge(5,5));
			//g.nodes[3].Add(new Edge(4,6));
			//g.nodes[4].Add(new Edge(2,7));
			//g.nodes[4].Add(new Edge(5,8));
			////GraphWeights gw = residualGraph(g,c,f);
			////for(int i=0;i<10;i++){
			////	Console.WriteLine(gw.w[i]);
			////}
			//Console.WriteLine(EdmondsKarp(g,c,0,5));
		}
	}
}