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 {

	InputReader in;
	PrintWriter out;

	Main() throws IOException {
		in = new InputReader(System.in);
		out = new PrintWriter(System.out);
		//in = new InputReader(new FileInputStream("output_.txt"));
		// out = new PrintWriter(new File("output_.txt"));
		solve();
		out.close();
	}

	public static void main(String args[]) {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, "1", 1 << 26).start();
	}

	// --------------------My Code Starts Here----------------------
	long mod = (long) 1e9 + 7;
	double eps = 1e-5;

	public void solve() throws IOException {
		int n = in.nextInt();
		int m = in.nextInt();
		int a[][] = new int[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				a[i][j] = in.nextInt();
			}
		}
		int min = 1000;
		for (int i = 0; i < m; i++) {
			min = Math.min(min, a[0][i]);
		}
		int ans = Integer.MAX_VALUE;
		int ind=-1;
		for (int i = 0; i <= min; i++) {
			int val = solve_val(copy(a), n, m, i);
			if (ans > val) {
				ans = val;
				ind=i;
			}
		}
		//System.out.println(ind);
		if (ans == Integer.MAX_VALUE) {
			out.println("-1");
		} else {
			solve(copy(a), n, m, ind);
			out.println(ans);
			for (String x : arr) {
				out.println(x);
			}
		}
	}

	// ---------------------My Code Ends Here----------------------
	ArrayList<String> arr = new ArrayList<>();

	int solve_val(int a[][], int n, int m, int x) {
		int ans=0;
		for (int j = 0; j < m; j++) {
			a[0][j] -= x;
		}
		ans+=x;
		for (int j = 0; j < m; j++) {
			int rem = a[0][j];
			for (int i = 0; i < n; i++) {
				a[i][j] -= rem;
			}
			if (rem != 0) {
				ans+=rem;
			}
		}
		boolean ok = true;
		for (int i = 0; i < n; i++) {
			boolean mid = true;
			for (int j = 0; j < m; j++) {
				if (a[i][j] != a[i][0] || a[i][j]<0) {
					mid = false;
				}
			}
			ok = ok & mid;
		}
		if (!ok) {
			return Integer.MAX_VALUE;
		} else {
			for (int i = 0; i < n; i++) {
				if (a[i][0] != 0) {
					ans+= a[i][0];
				}
			}
			return ans;
		}
	}
	
	int solve(int a[][], int n, int m, int x) {
		arr.clear();
		for (int j = 0; j < m; j++) {
			a[0][j] -= x;
		}
		put("row", 1, x);
		for (int j = 0; j < m; j++) {
			int rem = a[0][j];
			for (int i = 0; i < n; i++) {
				a[i][j] -= rem;
			}
			if (rem != 0) {
				put("col", j + 1, rem);
			}
		}
		boolean ok = true;
		for (int i = 0; i < n; i++) {
			boolean mid = true;
			for (int j = 0; j < m; j++) {
				if (a[i][j] != a[i][0] || a[i][j]<0) {
					mid = false;
				}
			}
			ok = ok & mid;
		}
		if (!ok) {
			return Integer.MAX_VALUE;
		} else {
			for (int i = 0; i < n; i++) {
				if (a[i][0] != 0) {
					put("row", i + 1, a[i][0]);
				}
			}
			return arr.size();
		}
	}

	int[][] copy(int a[][]) {
		int n = a.length;
		int m = a[0].length;
		int cp[][] = new int[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				cp[i][j] = a[i][j];
			}
		}
		return cp;
	}

	void put(String s, int num, int x) {
		for (int i = 0; i < x; i++) {
			arr.add(s + " " + num);
		}
	}

	static long modulo(long a, long b, long c) {
		long x = 1;
		long y = a;
		while (b > 0) {
			if (b % 2 == 1) {
				x = (x * y) % c;
			}
			y = (y * y) % c; // squaring the base
			b /= 2;
		}
		return x % c;
	}

	static class Pair implements Comparable<Pair> {
		int x;
		int y;
		int depth;

		Pair(int xx, int yy) {
			x = xx;
			y = yy;
			depth = 0;
		}

		@Override
		public int compareTo(Pair o) {
			if (Long.compare(this.y + this.x, o.y + o.x) != 0)
				return -Long.compare(this.y + this.x, o.y + o.x);
			else
				return -Long.compare(this.x - this.y, o.x - o.y);
		}
	}

	public static void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}

	static final class InputReader {
		private final InputStream stream;
		private final byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

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

		private int read() throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read(buf);
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public final int nextInt() throws IOException {
			return (int) nextLong();
		}

		public final long nextLong() throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
				if (c == -1)
					throw new IOException();
			}
			boolean negative = false;
			if (c == '-') {
				negative = true;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += (c - '0');
				c = read();
			} while (!isSpaceChar(c));
			return negative ? (-res) : (res);
		}

		public final int[] readIntBrray(int size) throws IOException {
			int[] arr = new int[size];
			for (int i = 0; i < size; i++)
				arr[i] = nextInt();
			return arr;
		}

		public final String next() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public final String nextLine() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (c != '\n' && c != -1);
			return res.toString();
		}

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