Problem: On the way to school, Karen became fixated on the puzzle game on her phone!

<image>

The game is played as follows. In each level, you have a grid with n rows and m columns. Each cell originally contains the number 0.

One move consists of choosing one row or column, and adding 1 to all of the cells in that row or column.

To win the level, after all the moves, the number in the cell at the i-th row and j-th column should be equal to gi, j.

Karen is stuck on one level, and wants to know a way to beat this level using the minimum number of moves. Please, help her with this task!

Input

The first line of input contains two integers, n and m (1 ≤ n, m ≤ 100), the number of rows and the number of columns in the grid, respectively.

The next n lines each contain m integers. In particular, the j-th integer in the i-th of these rows contains gi, j (0 ≤ gi, j ≤ 500).

Output

If there is an error and it is actually not possible to beat the level, output a single integer -1.

Otherwise, on the first line, output a single integer k, the minimum number of moves necessary to beat the level.

The next k lines should each contain one of the following, describing the moves in the order they must be done:

  * row x, (1 ≤ x ≤ n) describing a move of the form "choose the x-th row". 
  * col x, (1 ≤ x ≤ m) describing a move of the form "choose the x-th column". 



If there are multiple optimal solutions, output any one of them.

Examples

Input

3 5
2 2 2 3 2
0 0 0 1 0
1 1 1 2 1


Output

4
row 1
row 1
col 4
row 3


Input

3 3
0 0 0
0 1 0
0 0 0


Output

-1


Input

3 3
1 1 1
1 1 1
1 1 1


Output

3
row 1
row 2
row 3

Note

In the first test case, Karen has a grid with 3 rows and 5 columns. She can perform the following 4 moves to beat the level:

<image>

In the second test case, Karen has a grid with 3 rows and 3 columns. It is clear that it is impossible to beat the level; performing any move will create three 1s on the grid, but it is required to only have one 1 in the center.

In the third test case, Karen has a grid with 3 rows and 3 columns. She can perform the following 3 moves to beat the level:

<image>

Note that this is not the only solution; another solution, among others, is col 1, col 2, col 3.

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class C 
{

	static StringBuilder st = new StringBuilder();
	
	public static void main(String[] args) throws Exception 
	{
		Scanner sc = new Scanner(System.in) ; 
		PrintWriter out = new PrintWriter(System.out) ; 
		
		int n = sc.nextInt() , m = sc.nextInt() ; 
		
		int [][] g  = new int [n][m]; 
		for(int i = 0 ;i < n ; i++)
			for(int j = 0 ; j < m ; j++)
				g[i][j] = sc.nextInt() ; 
		
		
		Node node = (new Node(new int [n][m] , new StringBuilder())) ; 
		
		if(n > m)
		{
			outer : 
			while(true)
			{
			
				for(int j = 0 ; j < m ;j++)
					if(node.checkCol(j, g))
					{
						node.incrementCol(j);
						continue outer ; 
						
					}
				for(int i = 0 ; i < n ;i++)
					if(node.checkRow(i, g))
					{
						node.incrementRow(i);
						continue outer ; 
						
					}
				break ; 
			}
		}
		else
		{
			
			outer : 
			while(true)
			{
			
				for(int i = 0 ; i < n ;i++)
					if(node.checkRow(i, g))
					{
						node.incrementRow(i);
						continue outer ; 
						
					}
			
				for(int j = 0 ; j < m ;j++)
					if(node.checkCol(j, g))
					{
						node.incrementCol(j);
						continue outer ; 
						
					}
				break ;
			}
			
		}
		
		if(node.reachTarget(g))
		{
		
			out.println(node.dist);
			out.println(node.st);
		}
		else
			out.println(-1);
		
		out.flush();
		out.close(); 
		
		
	}
	
	static class Node
	{
		int [][] mat ; 
		StringBuilder st ; 
		int dist = 0 ; 
		Node(int [][] mat , StringBuilder st)
		{
			this.mat = new int[mat.length][mat[0].length] ; 
			
			for(int i = 0  ; i < mat.length ;i++ )
				for(int j = 0  ; j < mat[i].length ;j++ )
					this.mat[i][j] = mat[i][j] ; 	
			
			this.st = new StringBuilder().append(st) ; 
		}
		
		boolean checkRow(int i , int [][] g)
		{
			boolean can = true ; 
			
			for(int j = 0 ; j < mat[i].length ; j++)
				can &= mat[i][j] + 1 <= g[i][j] ;
			
			return can ; 
		}
		
		boolean reachTarget(int [][] g)
		{
			boolean can = true ; 
			
			for(int i = 0 ; i < g.length ; i++)
				for(int j = 0 ; j < g[i].length ; j++)
					can &= g[i][j] == mat[i][j] ; 
			
			return can ; 
		}
		
		
		boolean checkCol(int j , int [][] g)
		{
			boolean can = true ; 
			
			for(int i = 0 ; i < mat.length ; i++)
				can &= mat[i][j] + 1 <= g[i][j] ;
			
			return can ; 
	
		}
		
		void incrementRow(int i)
		{
			st.append("row").append(" ").append(i+1).append("\n");
			
			for(int j = 0 ; j < mat[i].length ; j++)
				mat[i][j] ++ ;
			
			dist ++ ; 
			
		}
		
		void incrementCol(int j )
		{
			st.append("col").append(" ").append(j+1).append("\n");
			
			for(int i = 0 ; i < mat.length ; i++)
				mat[i][j] ++ ;
			dist ++ ; 
		}
		
		
	}

	static class Scanner 
	{
		BufferedReader br;
		StringTokenizer st;

		Scanner(InputStream in) 
		{
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() throws Exception 
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		int nextInt() throws Exception { return Integer.parseInt(next()); }

		long nextLong() throws Exception { return Long.parseLong(next()); }

		double nextDouble() throws Exception { return Double.parseDouble(next());}

	}

	static void shuffle(int[] a) 
	{
		int n = a.length;
		for (int i = 0; i < n; i++) 
		{
			int r = i + (int) (Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
	}

}