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

public class Main {

    class IOManager {
        BufferedReader reader;
        PrintWriter writer;
        StringTokenizer tokenizer;

        IOManager() {
            reader = new BufferedReader(new InputStreamReader(System.in));
            writer = new PrintWriter(new BufferedOutputStream(System.out));
        }

        IOManager(String file) throws FileNotFoundException {
            reader = new BufferedReader(new FileReader(file));
            writer = new PrintWriter(new BufferedOutputStream(System.out));
        }

        String next() throws IOException {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                String line = reader.readLine();
                if (line == null)
                    throw new IOException("No lines left.");
                tokenizer = new StringTokenizer(line);
            }
            return tokenizer.nextToken();
        }

        public Integer nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public Long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public Double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public void writeSpace(Object obj) {
            writer.print(obj.toString() + " ");
        }

        public void writeLine(Object obj) {
            writer.println(obj.toString());
        }

        public void writeDouble(Double x, int n) {
            String format = "%." + n + "f";
            writer.printf(format, x);
        }

        public void write(Object obj) {
            writer.print(obj.toString());
        }

        public void close() {
            writer.close();
        }
    }

    class Pair implements Comparable {
        public long u, v;

        public Pair(long u, long v) {
            this.u = u;
            this.v = v;
        }

        @Override
        public int compareTo(Object o) {
            Pair that = (Pair) o;
            if (Long.compare(u, that.u) != 0)
                return Long.compare(u, that.u);
            return Long.compare(v, that.v);
        }
    }

    class Graph {
        public int n, m;
        public List<Integer>[] adj;

        public Graph(int n, int m) {
            this.n = n;
            this.m = m;
            adj = new List[n + 1];
            for (int i = 0; i <= n; ++i) {
                adj[i] = new ArrayList<>();
            }
        }

        public void add(int u, int v) {
            adj[u].add(v);
        }

        public void add2Ways(int u, int v) {
            add(u, v);
            add(v, u);
        }

        public void dfs(int i, boolean fr[]) {
            fr[i] = false;
            for (int j: adj[i]) {
                if (fr[j]) {
                    dfs(j, fr);
                }
            }
        }

        public boolean isConnected() {
            boolean fr[] = new boolean[n + 1];
            Arrays.fill(fr, true);
            dfs(1, fr);
            for (int i = 2; i <= n; ++i) {
                if (fr[i])
                    return false;
            }
            return true;
        }

        public boolean hasEuclideanPath() {
            if (!isConnected())
                return false;
            int cnt = 0;
            for (int i = 1; i <= n; ++i) {
                if (adj[i].size() % 2 == 1)
                    cnt++;
            }
            return cnt <= 2;
        }

        public boolean dfsHamiltonian(int i, boolean[] fr, int reached) {
            fr[i] = false;
            reached++;
            if (reached == n)
                return true;
            for (int j: adj[i]) {
                if (fr[j]) {
                    if (dfsHamiltonian(j, fr, reached))
                        return true;
                }
            }
            fr[i] = true;
            return false;
        }

        public boolean hasHamiltonianPathFrom(int st) {
            boolean fr[] = new boolean[n + 1];
            Arrays.fill(fr, true);
            return dfsHamiltonian(st, fr, 0);
        }
    }

    // Actually rooted forest
    class Tree extends Graph {

        public Tree(int n, int m) {
            super(n, m);
        }

        public int getHeight(int i) {
            int res = 0;
            for (Integer j: adj[i]) {
                res = Math.max(res, getHeight(j) + 1);
            }
            return res;
        }
    }

    class FenwickTree {
        int n;
        int tree[];

        public FenwickTree() {

        }

        public FenwickTree(int maxn) {
            n = maxn;
            tree = new int[maxn + 10];
        }

        public void add(int i, int x) {
            while (i <= n) {
                tree[i] += x;
                i += i & (-i);
            }
        }

        public void add(int i) {
            add(i, 1);
        }

        public int get(int i) {
            int res = 0;
            while (i > 0) {
                res += tree[i];
                i -= i & (-i);
            }
            return res;
        }
    }

    IOManager ioManager;

    Main() {
        ioManager = new IOManager();
    }

    Main(String file) throws FileNotFoundException {
        ioManager = new IOManager(file);
    }

    final int inf = (int) 1e9;

    int m, n;
    int a[][];
    int r[], c[];

    int kt(int x) {
        r[1] = x;
        int sum = x;
        for (int i = 1; i <= n; ++i) {
            c[i] = a[1][i] - x;
            sum += c[i];
        }
        for (int i = 2; i <= m; ++i) {
            r[i] = a[i][1] - c[1];
            if (r[i] < 0)
                return -1;
            sum += r[i];
        }
        for (int i = 2; i <= m; ++i) {
            for (int j = 2; j <= n; ++j) {
                if (a[i][j] != r[i] + c[j])
                    return -1;
            }
        }
        return sum;
    }

    void solve() throws IOException {
        m = ioManager.nextInt();
        n = ioManager.nextInt();
        a = new int[m + 10][n + 10];
        r = new int[m + 10];
        c = new int[n + 10];
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                a[i][j] = ioManager.nextInt();
            }
        }

        int a1min = inf;
        for (int i = 1; i <= n; ++i) {
            a1min = Math.min(a1min, a[1][i]);
        }
        int res = inf, ri = -1;
        for (int i = 0; i <= a1min; ++i) {
            int tmp = kt(i);
            if (tmp != -1 && tmp < res) {
                res = tmp;
                ri = i;
            }
        }
        if (res == inf) {
            ioManager.writeLine(-1);
            return;
        }
        kt(ri);
        ioManager.writeLine(res);
        for (int u = 1; u <= m; ++u) {
            for (int v = 1; v <= r[u]; ++v) {
                ioManager.writeLine("row " + u);
            }
        }
        for (int u = 1; u <= n; ++u) {
            for (int v = 1; v <= c[u]; ++v) {
                ioManager.writeLine("col " + u);
            }
        }
    }

    void close() {
        ioManager.close();
    }

    public static void main(String args[]) throws IOException {
        Main solver;
        if (!"true".equals(System.getProperty("ONLINE_JUDGE"))) {
            solver = new Main("input.txt");
        } else {
            solver = new Main();
        }
        solver.solve();
        solver.close();
    }
}