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.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;


public class ques3 {

	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 static boolean isWhitespace(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		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 boolean isSpaceChar(int c) {
			if (filter != null) {
				return filter.isSpaceChar(c);
			}
			return isWhitespace(c);
		}

		public interface SpaceCharFilter {

			public boolean isSpaceChar(int ch);
		}

		public String next() {
			return nextString();
		}

		public char nextChar(){
			int c=read();
			while (isSpaceChar(c)) {
				c = read();
			}
			return (char)c;
		}

		public String nextString() {
			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 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() {
			return Long.parseLong(nextString());
		}

		public Double nextDouble() {
			return Double.parseDouble(nextString());
		}
	}

	public static void main(String[] args) {
		InputReader s=new InputReader(System.in);
		int n=s.nextInt();
		int m=s.nextInt();
		int a[][]=new int[n][m];
		int b[][]=new int[m][n];
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
				a[i][j]=s.nextInt();
		}
		
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
				b[j][i]=a[i][j];
		}
		StringBuilder ans1=new StringBuilder();
		StringBuilder ans2=new StringBuilder();
		int moves1=func1(a,ans1);
		int moves2=func2(b,ans2);
		
		if(moves1==-1&&moves2==-1)
			System.out.println(-1);
		else if(moves1==-1||moves2==-1)
		{
			System.out.println("check1");
			if(moves1==-1)
			{
				System.out.println(moves2);
				System.out.println(ans2);
			}
			else
			{
				System.out.println(moves1);
				System.out.println(ans1);
			}
		}
		else
		{

			if(moves1<moves2)
			{
				System.out.println(moves1);
				System.out.println(ans1);
			}
			else
			{
				System.out.println(moves2);
				System.out.println(ans2);
			}
		}		
	}
	
	public static int func1(int a[][],StringBuilder out)
	{
		int choice;
		int n=a.length;
		int m=a[0].length;
		
		int minrow[]=new int[n];
		int mincol[]=new int[m];
		int rowSum=0,colSum=0;
		for(int i=0;i<n;i++)
		{
			int min=Integer.MAX_VALUE;
			for(int j=0;j<m;j++)
			{
				min=Math.min(min, a[i][j]);
			}
			minrow[i]=min;
			rowSum+=minrow[i];
		}

		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
				a[i][j]-=minrow[i];
		}

		boolean ans=true;
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				if(a[i][j]!=0)
				{	
					ans=false;
					break;
				}
			}
			if(!ans)
				break;
		}
		
		if(ans)
		{
			choice=rowSum;
			for(int i=0;i<n;i++)
			{
				int temp=minrow[i];
				while(temp>0)
				{
					out.append("row ").append((i+1)).append('\n');
					temp--;
				}
			}
			return choice;
		}
		

		for(int j=0;j<m;j++)
		{
			int min=Integer.MAX_VALUE;
			for(int i=0;i<n;i++)
			{
				min=Math.min(min, a[i][j]);
			}
			mincol[j]=min;
			colSum+=mincol[j];
		}
		for(int j=0;j<m;j++)
		{
			for(int i=0;i<n;i++)
				a[i][j]-=mincol[j];
		}
		ans=true;
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				if(a[i][j]!=0)
				{	
					ans=false;
					break;
				}
			}
			if(!ans)
				break;
		}
		if(ans)
		{
			choice=rowSum+colSum;
			for(int i=0;i<n;i++)
			{
				int temp=minrow[i];
				while(temp>0)
				{
					out.append("row ").append((i+1)).append('\n');
					temp--;
				}
			}
			for(int j=0;j<m;j++)
			{
				int temp=mincol[j];
				while(temp>0)
				{
					out.append("col ").append((j+1)).append('\n');
					temp--;
				}
			}
		}
		else
			choice=-1;
		

		return choice;
	}
	
	public static int func2(int a[][],StringBuilder out)
	{
		int choice;
		int n=a.length;
		int m=a[0].length;
		
		int minrow[]=new int[n];
		int mincol[]=new int[m];
		int rowSum=0,colSum=0;
		for(int i=0;i<n;i++)
		{
			int min=Integer.MAX_VALUE;
			for(int j=0;j<m;j++)
			{
				min=Math.min(min, a[i][j]);
			}
			minrow[i]=min;
			rowSum+=minrow[i];
		}

		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
				a[i][j]-=minrow[i];
		}

		boolean ans=true;
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				if(a[i][j]!=0)
				{	
					ans=false;
					break;
				}
			}
			if(!ans)
				break;
		}
		
		if(ans)
		{
			choice=rowSum;
			for(int i=0;i<n;i++)
			{
				int temp=minrow[i];
				while(temp>0)
				{
					out.append("col ").append((i+1)).append('\n');
					temp--;
				}
			}
			return choice;
		}
		

		for(int j=0;j<m;j++)
		{
			int min=Integer.MAX_VALUE;
			for(int i=0;i<n;i++)
			{
				min=Math.min(min, a[i][j]);
			}
			mincol[j]=min;
			colSum+=mincol[j];
		}
		for(int j=0;j<m;j++)
		{
			for(int i=0;i<n;i++)
				a[i][j]-=mincol[j];
		}
		ans=true;
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				if(a[i][j]!=0)
				{	
					ans=false;
					break;
				}
			}
			if(!ans)
				break;
		}
		if(ans)
		{
			choice=rowSum+colSum;
			for(int i=0;i<n;i++)
			{
				int temp=minrow[i];
				while(temp>0)
				{
					out.append("col ").append((i+1)).append('\n');
					temp--;
				}
			}
			for(int j=0;j<m;j++)
			{
				int temp=mincol[j];
				while(temp>0)
				{
					out.append("row ").append((j+1)).append('\n');
					temp--;
				}
			}
		}
		else
			choice=-1;
		

		return choice;
	}

}