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.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.List;
import java.util.ArrayList;


public class Karen{

	public static int [][]mtx;
	public static void main(String[] args){
		List<String> line = getRawInput();			
		int n = Integer.parseInt(line.get(0).split(" ")[0]);
		int m = Integer.parseInt(line.get(0).split(" ")[1]);
		

		mtx = new int[n][m];

		boolean allZero = true;

		


		for (int i=1;i<=n;i++){
			String [] parsed = line.get(i).split(" ");
			for (int j=0;j<m;j++){
				mtx[i-1][j]= Integer.parseInt(parsed[j]);
			}
		}	
		
		List <String> result = new ArrayList<>();
		List <Integer> minPerLine = new ArrayList<>();
		List <Integer> minPerCol = new ArrayList<>();


		allZero = checkZero(n,m,mtx);


		if (!allZero){
			if (n<=m){
				for (int i=0;i<n;i++){
					int value = 500;
		                        for (int j=0;j<m;j++){
						if (mtx[i][j]>0 && value >= mtx[i][j]){
							value = mtx[i][j];
						}else if (mtx[i][j]==0){
							value = 0;
							break;
						}
					}
					minPerLine.add(value);
				} 
	
				 for (int i=0;i<n;i++){
		                        if (minPerLine.get(i)>0 && minPerLine.get(i)<=500){
		                                for (int j=0;j<m;j++){
		                                        mtx[i][j]=mtx[i][j]-minPerLine.get(i);
		                                }
		                                for (int k=0;k<minPerLine.get(i);k++)
		                                        result.add("row "+(i+1));
		                        }
		
		                }
		
		
	
	
				 for (int i=0;i<m;i++){
		                        int value = 500;
		                        for (int j=0;j<n;j++){
		                                if (mtx[j][i]>0 && value >= mtx[j][i]){
		                                        value = mtx[j][i];
	        	                        }else if (mtx[j][i]==0){
		                                        value = 0;
		                                        break;
		                                }
		                        }
		                        minPerCol.add(value);
		                } 	
					
		
		            	for (int i=0;i<m;i++){
		                        if (minPerCol.get(i)>0 && minPerCol.get(i)<=500){
		                                for (int j=0;j<n;j++){
		                                        mtx[j][i]=mtx[j][i]-minPerCol.get(i);
		                                }
						for (int k=0;k<minPerCol.get(i);k++)
							result.add("col "+(i+1));	
		                        }
		                }
	
				boolean zero = checkZero(n,m,mtx);
				if (result.size()>0 && zero){				
					System.out.println(result.size());
					for (String str:result){
						System.out.println(str);
					}
				}else{
					System.out.println("-1");
				}	
			}else{






				for (int i=0;i<m;i++){
                                        int value = 500;
                                        for (int j=0;j<n;j++){
                                                if (mtx[j][i]>0 && value >= mtx[j][i]){
                                                        value = mtx[j][i];
                                                }else if (mtx[j][i]==0){
                                                        value = 0;
                                                        break;
                                                }
                                        }
                                        minPerCol.add(value);
                                }


                                for (int i=0;i<m;i++){
                                        if (minPerCol.get(i)>0 && minPerCol.get(i)<=500){
                                                for (int j=0;j<n;j++){
                                                        mtx[j][i]=mtx[j][i]-minPerCol.get(i);
                                                }
                                                for (int k=0;k<minPerCol.get(i);k++)
                                                        result.add("col "+(i+1));
                                        }
                                }




				 for (int i=0;i<n;i++){
                                        int value = 500;
                                        for (int j=0;j<m;j++){
                                                if (mtx[i][j]>0 && value >= mtx[i][j]){
                                                        value = mtx[i][j];
                                                }else if (mtx[i][j]==0){
                                                        value = 0;
                                                        break;
                                                }
                                        }
                                        minPerLine.add(value);
                                }

                                 for (int i=0;i<n;i++){
                                        if (minPerLine.get(i)>0 && minPerLine.get(i)<=500){
                                                for (int j=0;j<m;j++){
                                                        mtx[i][j]=mtx[i][j]-minPerLine.get(i);
                                                }
                                                for (int k=0;k<minPerLine.get(i);k++)
                                                        result.add("row "+(i+1));
                                        }

                                }

                                boolean zero = checkZero(n,m,mtx);
                                if (result.size()>0 && zero){
                                        System.out.println(result.size());
                                        for (String str:result){
                                                System.out.println(str);
                                        }
                                }else{
                                        System.out.println("-1");
                                }


			}
		}else{
			System.out.println("0");
		}


			
	}

	
	public static boolean checkZero(int n, int m, int [][]mtx){
		boolean allZero = true;
		 for (int i=0;i<n;i++){
	                        for (int j=0;j<m;j++){
	                                if (mtx[i][j]!=0){
	                                        allZero=false;
	                                        break;
	                                }
	                        }
	                        if (!allZero)
	                                break;
	         }
		return allZero;
	}



	public static List<String> getRawInput(){
		List<String> line = new ArrayList<>();
		
		try{
                        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));			
			int k=0;
			line.add(br.readLine().trim());
			int n = Integer.parseInt(line.get(0).split(" ")[0]);
                        while(k<n && line.add(br.readLine().trim())  && !line.get(line.size()-1).trim().equals("")){
				k++;
			}
                } catch(IOException e){
                        e.printStackTrace();
                }
		return line;

	}
}