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

public class KarenAndGame 
{
    static boolean debug = false ;
    public static void main(String args[]) throws Exception 
    {
        BufferedReader bro = new BufferedReader(new InputStreamReader(System.in)) ;
        String[] S = bro.readLine().split(" ") ;
        int n = Integer.parseInt(S[0]) ;
        int m = Integer.parseInt(S[1]) ;
        int[][] M = new int[n][m] ;
        for(int i=0;i<n;i++)
        {
            S = bro.readLine().split(" ") ;
            for(int j=0;j<m;j++)
            {
                M[i][j] = Integer.parseInt(S[j]) ;
            }
        }
        List<String> ans = new ArrayList<String>() ;
        
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;)
            {
                if(M[i][j]>0)
                {
                    if(debug)
                    {
                        System.out.println("Visited :"+(i+1)+" "+(j+1));
                    }
                    boolean row = m>n ;
                    int rowMin = minRow(M, i) ;
                    int colMin = minCol(M, j) ;
                    if(rowMin>0 && (row || colMin==0)) 
                    {
                        for(int k=0;k<rowMin;k++) ans.add("row "+(i+1)) ;
                        if(debug)
                        {
                            System.out.println("    Deleted row:"+rowMin) ;
                            
                        }
                        for(int c=0;c<m;c++)
                        {
                            M[i][c]-=rowMin ;
                        }
                    }
                    else if(colMin>0 && (!row || rowMin==0))
                    {
                        for(int k=0;k<colMin;k++) ans.add("col "+(j+1)) ;
                        if(debug)
                        {
                            System.out.println("    Deleted col:"+colMin) ;
                            
                        }
                        for(int r=0;r<n;r++)
                        {
                            M[r][j]-= colMin ;
                        }
                    }
                    
                    else 
                    {
                        System.out.println("-1") ;
                        return ;
                    }

                }
                else j++ ;
            }
        }
        System.out.println(ans.size()) ;
        for(int i=0;i<ans.size();i++) 
            System.out.println(ans.get(i));
        

    }
    static int minRow(int[][] M,int r)
    {
        int  min = Integer.MAX_VALUE ;
        for(int i=0;i<M[0].length;i++) min = Math.min(M[r][i],min) ;
        return min ;
    }
    static int minCol(int[][] M,int c)
    {
        int min = Integer.MAX_VALUE ;
        for(int i=0;i<M.length;i++) min = Math.min(min,M[i][c]) ;
        return min ;
    }
}
/* 
10 11
8 7 10 15 5 13 12 9 14 11 6
6 5 8 13 3 11 10 7 12 9 4
10 9 12 17 7 15 14 11 16 13 8
9 8 11 16 6 14 13 10 15 12 7
12 11 14 19 9 17 16 13 18 15 10
14 13 16 21 11 19 18 15 20 17 12
7 6 9 14 4 12 11 8 13 10 5
5 4 7 12 2 10 9 6 11 8 3
11 10 13 18 8 16 15 12 17 14 9
13 12 15 20 10 18 17 14 19 16 11
*/