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.
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

/* spar5h */

public class codeforces implements Runnable
{    
	
	public void run() {
		
		InputReader s = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);
		
		int n = s.nextInt();
		int m = s.nextInt();
		
		int[][] a = new int[n + 1][m + 1];
		int[][] a2 = new int[n + 1][m + 1];
		
		int[] r = new int[n + 1];
		int[] c = new int[m + 1];
		int[] r2 = new int[n + 1];
		int[] c2 = new int[m + 1];
		
		boolean b = true;
		
		int sum = 0;
		int sum2 = 0;
		
		for(int i = 1; i <= n; i++) {
			
			for(int j = 1; j <= m; j++) {
				
				a[i][j] = s.nextInt(); a2[i][j] = a[i][j];
			}	
		}
		
		for(int i = 1; i <= n; i++) {
			
			int min = 501;
			
			for(int j = 1; j <= m; j++) {
				
				if(min > a[i][j])
					min = a[i][j];
			}
			
			for(int j = 1; j <= m; j++)
				a[i][j] -= min;
			
			r[i] = min;
			sum += min;
		}		
		
		outerloop:
		for(int j = 1; j <= m; j++) {
			
			int key = a[1][j];
			
			for(int i = 2; i <= n; i++) {
				
				if(a[i][j] != key) {
					
					b = false;
					break outerloop;
				}
				
			}

			c[j] = key;
			sum += key;
		}
		
		
		for(int j = 1; j <= m; j++) {
			
			int min = 501;
			
			for(int i = 1; i <= n; i++) {
				
				if(min > a2[i][j])
					min = a2[i][j];
			}
			
			for(int i = 1; i <= n; i++)
				a2[i][j] -= min;
			
			c2[j] = min;
			sum2 += min;
		}		
		
		outerloop2:
		for(int i = 1; i <= n; i++) {
			
			int key = a2[i][1];
			
			for(int j = 2; j <= m; j++) {
				
				if(a2[i][j] != key) {
					
					b = false;
					break outerloop2;
				}
				
			}
		
			r2[i] = key; 
			sum2 += key;
		}
		
		if(b) {
			
			
			if(sum < sum2) {
				
				w.println(sum);
				
				for(int i = 1; i <= n; i++) {
					
					for(int k = 0; k < r[i]; k++)
						w.println("row " + i);
				}
				
				for(int j = 1; j <= m; j++) {
					
					for(int k = 0; k < c[j]; k++)
						w.println("col " + j);
				}
				
			}
			
			else {
				
				w.println(sum2);
				
				for(int i = 1; i <= n; i++) {
					
					for(int k = 0; k < r2[i]; k++)
						w.println("row " + i);
				}
				
				for(int j = 1; j <= m; j++) {
					
					for(int k = 0; k < c2[j]; k++)
						w.println("col " + j);
				}
			}
			
			
		}
		
		else {
			
			w.println(-1);
		}
		
		w.close();
	}
	
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		
		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}
		
		public int read()
		{
			if (numChars==-1) 
				throw new InputMismatchException();
			
			if (curChar >= numChars)
			{
				curChar = 0;
				try 
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}
				
				if(numChars <= 0)				
					return -1;
			}
			return buf[curChar++];
		}
	 
		public String nextLine()
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();
			
			while(isSpaceChar(c)) 
				c = read();
			
			int sgn = 1;
			
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			
			int res = 0;
			do 
			{
				if(c<'0'||c>'9') 
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c)); 
			
			return res * sgn;
		}
		
		public long nextLong() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			long res = 0;
			
			do 
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}
		
		public double nextDouble() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') 
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') 
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) 
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}
		
		public String readString() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do 
			{
				res.appendCodePoint(c);
				c = read();
			} 
			while (!isSpaceChar(c));
			
			return res.toString();
		}
	 
		public boolean isSpaceChar(int c) 
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	 
		public String next() 
		{
			return readString();
		}
		
		public interface SpaceCharFilter 
		{
			public boolean isSpaceChar(int ch);
		}
	}
    
	public static void main(String args[]) throws Exception
	{
		new Thread(null, new codeforces(),"codeforces",1<<26).start();
	}
	   
}