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 javax.swing.text.AbstractDocument.LeafElement;

import java.io.*;
import java.lang.*;
import java.lang.Character.Subset;
import java.math.*;
public class cf3 {
	 static class pair implements Comparable<pair>
		{
			Long x,y;
			pair(long x,long y)
			{
				this.x=x;
				this.y=y;
			}
			public int compareTo(pair o) {
				if(x!=o.x)
					return x.compareTo(o.x);
				else
					return y.compareTo(o.y);
			}  
		}
	static long mod=1000000007;
	static boolean prime[];
	public static void main(String args[])
	{
		InputReader in=new InputReader(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		int m=in.nextInt();
		int n=in.nextInt();
		int[][] arr=new int[m][n];
		int[][] ans=new int[m][n];
		for(int i=0;i<m;i++)
		{
			for(int j=0;j<n;j++)
			{
				arr[i][j]=0;
				ans[i][j]=in.nextInt();
			}
		}
		ArrayList<String> list=new ArrayList<>();
		boolean flag2=false;
		if(m<n)
		{
			while(true)
			{
				if(check(arr,ans))
					break;
				if(flag2)
					break;
				flag2=true;
				for(int i=0;i<m;i++)
				{
					while(row(arr,ans,i))
					{
						flag2=false;
						for(int j=0;j<n;j++)
							arr[i][j]++;
						list.add("row "+Integer.toString(i+1));
					}
				}
				for(int i=0;i<n;i++)
				{
					while(col(arr,ans,i))
					{
						flag2=false;
						for(int j=0;j<m;j++)
							arr[j][i]++;
						list.add("col "+Integer.toString(i+1));
					}
				}
			}
			if(flag2)
				pw.println("-1");
			else
			{
				pw.println(list.size());
				for(int i=0;i<list.size();i++)
					pw.println(list.get(i));
			}
		}
		else
		{
			while(true)
			{
				if(check(arr,ans))
					break;
				if(flag2)
					break;
				flag2=true;
				for(int i=0;i<n;i++)
				{
					while(col(arr,ans,i))
					{
						flag2=false;
						for(int j=0;j<m;j++)
							arr[j][i]++;
						list.add("col "+Integer.toString(i+1));
					}
				}
				for(int i=0;i<m;i++)
				{
					while(row(arr,ans,i))
					{
						flag2=false;
						for(int j=0;j<n;j++)
							arr[i][j]++;
						list.add("row "+Integer.toString(i+1));
					}
				}
			}
			if(flag2)
				pw.println("-1");
			else
			{
				pw.println(list.size());
				for(int i=0;i<list.size();i++)
					pw.println(list.get(i));
			}
		}
		pw.flush();
	}
	public static boolean col(int[][] arr,int[][] ans,int j)
	{
		int m=arr.length;
		for(int i=0;i<m;i++)
		{
			if(arr[i][j]>=ans[i][j])
				return false;
		}
		return true;
	}
	public static boolean row(int[][] arr,int[][] ans,int i)
	{
		int m=arr[0].length;
		for(int j=0;j<m;j++)
		{
			if(arr[i][j]>=ans[i][j])
				return false;
		}
		return true;
	}
	public static boolean check(int[][] arr,int[][] ans)
	{
		int m=arr.length;
		int n=arr[0].length;
		for(int i=0;i<m;i++)
		{
			for(int j=0;j<n;j++)
			{
				if(arr[i][j]!=ans[i][j])
					return false;
			}
		}
		return true;
	}
	public static int distance(int x,int y,int p,int q)
	{
		int a=(x-p)*(x-p);
		int b=(y-q)*(y-q);
		int dis=a+b;
		return dis;
	}
	public static int bnum(int num)
	{
		int ans=0;
		for(int i=31;i>=0;i--)
		{
			if((num&(1<<i))!=0)
			{
				ans+=Math.pow(10,i);
			}
		}
		return ans;
	}
	public static int bsdown(int a[],int item)
	{
		int low=0,high=a.length-1,ans=-1;
		while(low<=high)
		{
			int mid=low+(high-low)/2;
			if(a[mid]<=item)
			{
				ans=mid;
				low=mid+1;
			}
			else
				high=mid-1;
				
		}
		return ans;
	}
	public static long inverse(long num)
	{
		return fastpow(num,mod-2,mod);
	}
	public static int bsupper(int a[],int item)
	{
		int low=0,high=a.length-1,ans=-1;
		while(low<=high)
		{
			int mid=low+(high-low)/2;
			if(a[mid]>=item)
			{
				ans=mid;
				high=mid-1;
			}
			else
				low=mid+1;
				
		}
		return ans;
	}	
	public static boolean isprime(int n)
	{
		for(int i=2;i*i<=n;i++)
		{
			if(n%i==0)
				return false;
		}
		return true;
	}
	public static long fact(long a,long mod)
	{
		long ans=1;
		for(int i=1;i<=a;i++)
		{
			ans*=i;
			ans%=mod;
		}
		return ans%mod;
		
	}
	public static long ncr(long n,long r,long mod)
	{
		long nom=1,dom=1;
		nom=(fact(n,mod))%mod;
		dom=(fact(r,mod)*fact(n-r,mod))%mod;
		return (nom*fastpow(dom,mod-2,mod))%mod;
	}
	public static long gcd(long x, long y)
	{
		if(x==0)
			return y;
		if(y==0)
			return x;
		long r=0, a, b;
		a = (x > y) ? x : y; // a is greater number
		b = (x < y) ? x : y; // b is smaller number
		r = b;
		while(a % b != 0)
		{
			r = a % b;
			a = b;
			b = r;
		}
		return r;
	}
	public static void prime(int n)
	{
		prime[0]=true;
		prime[1]=true;
		for(int i=2;i*i<=n;i++)
		{
			if(prime[i])
				continue;
			for(int j=i;j*i<=n;j++)
			{
				prime[i*j]=true;
			}
		}
	}
	static class InputReader {
		 
		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++) {
				a[i] = nextInt();
			}
			return a;
		}

		public String readString() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public String nextLine() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isEndOfLine(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;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
	public static long fastpow(long a,long b,long mod)
	{
		long ans=1;
		while(b!=0)
		{
			if(b%2==1)
			{
				ans=(ans*a)%mod;
			}
			a=(a*a)%mod;
			b/=2;
		}
		return ans;
	}
}