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

public class A {
    static class Node {
        int x;
        int d;

        public Node(int x,int d){
            this.x=x;
            this.d=d;

        }

    }
    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
        int n=sc.I();
        int m=sc.I();
        int a[][]=new int[n+1][m+1];
        int row[]=new int[n+1];
        int col[]=new int[m+1];

        for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) a[i][j]=sc.I();
        int mxr[]=new int[n+1];
        int mxc[]=new int[m+1];
        Arrays.fill(mxr,(int)1e9);
        Arrays.fill(mxc,(int)1e9);
        int ans=Integer.MAX_VALUE;
        for(int i=1;i<=n;i++) {
            for(int j=1;j<=m;j++){
                mxr[i]=Math.min(mxr[i],a[i][j]);
                mxc[j]=Math.min(mxc[j],a[i][j]);
            }
        }

        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(mxr[i]+mxc[j]<a[i][j]){
                    pw.println(-1);
                    pw.close();
                    return;
                }
            }
        }

        Queue<Node> qr=new LinkedList<>();
        Queue<Node> qc=new LinkedList<>();
        boolean is=false;

        out : for(int x=0;x<=mxr[1];x++) { int cnt=0;
            for (int j = 1; j <= m; j++) {
                col[j] = a[1][j] - x;
                if(col[j]<0) continue out;
            }
            for (int i = 2; i <= n; i++) {
                int pr = -1;
                for (int j = 1; j <= m; j++) {
                    if(a[i][j]-col[j]<0) continue out;
                    if (pr != -1 && a[i][j] - col[j] != pr) {
                        continue out;
                    }else {
                        pr=a[i][j]-col[j];
                    }
                }
            }

            for(int j=1;j<=m;j++) if(col[j]>0){  cnt+=col[j]; }
            for(int i=1;i<=n;i++){
                if(a[i][1]-col[1]>=0) {cnt+=a[i][1]-col[1]; }
            }

            if(cnt<ans) { ans=cnt;
            qc.clear(); qr.clear();
                for (int j = 1; j <= m; j++)
                    if (col[j] > 0) {
                        qc.offer(new Node(j, col[j]));
                        cnt += col[j];
                    }
                for (int i = 1; i <= n; i++) {
                    if (a[i][1] - col[1] >= 0) {
                        qr.offer(new Node(i, a[i][1] - col[1]));
                        cnt += a[i][1] - col[1];
                    }
                }
            }

        }
        if(ans==Integer.MAX_VALUE) pw.println(-1);
        else {
            pw.println(ans);
            while(!qr.isEmpty()){
                Node temp=qr.poll();
                int d=temp.d;
                while(d>0){
                    pw.println("row "+temp.x);
                    d--;
                }
            }
            while(!qc.isEmpty()){
                Node temp=qc.poll();
                int d=temp.d;
                while(d>0){
                    pw.println("col "+temp.x);
                    d--;
                }
            }
        }
        pw.close();


    }

    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(new InputStreamReader(System.in));

        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}