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.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;

public class CF419_1 {
	static int N;
	static int MOD = (int) (1e9 + 7);

	public static void main(String args[]) {
		InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int t = 1;
		while (t-- > 0) {
			int n = in.nextInt();
			int m = in.nextInt();
			int a[][] = new int[n][m];
			int b[][] = new int[n][m];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < m; j++) {
					a[i][j] = in.nextInt();
					b[i][j] = a[i][j];
				}
			}
			ArrayList<Integer> rr = new ArrayList<Integer>();
			ArrayList<Integer> cc = new ArrayList<Integer>();
			ArrayList<Integer> rr2 = new ArrayList<Integer>();
			ArrayList<Integer> cc2 = new ArrayList<Integer>();

			for (int i = 0; i < n; i++) {
				while (true) {
					int min = 700;
					for (int j = 0; j < m; j++) {
						min = Math.min(a[i][j], min);
					}

					if (min <= 0) {
						break;
					}
					for (int k = 0; k < min; k++) {
						rr.add(i + 1);
					}
					for (int j = 0; j < m; j++) {
						a[i][j] = a[i][j] - min;
					}
				}

			}
			for (int j = 0; j < m; j++) {
				while (true) {
					int min = 700;
					for (int i = 0; i < n; i++) {
						min = Math.min(a[i][j], min);
					}

					if (min <= 0) {
						break;
					}

					for (int k = 0; k < min; k++) {
						cc.add(j + 1);
					}
					for (int i = 0; i < n; i++) {
						a[i][j] = a[i][j] - min;
					}
				}

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

			if (flag == 1) {
				out.println("-1");
				out.close();
				return;
			}

			for (int j = 0; j < m; j++) {
				while (true) {
					int min = 700;
					for (int i = 0; i < n; i++) {
						min = Math.min(b[i][j], min);
					}

					if (min <= 0) {
						break;
					}

					for (int k = 0; k < min; k++) {
						cc2.add(j + 1);
					}
					for (int i = 0; i < n; i++) {
						b[i][j] = b[i][j] - min;
					}
				}

			}
			for (int i = 0; i < n; i++) {
				while (true) {
					int min = 700;
					for (int j = 0; j < m; j++) {
						min = Math.min(b[i][j], min);
					}

					if (min <= 0) {
						break;
					}
					for (int k = 0; k < min; k++) {
						rr2.add(i + 1);
					}
					for (int j = 0; j < m; j++) {
						b[i][j] = b[i][j] - min;
					}
				}

			}

			flag = 0;
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < m; j++) {
					if (b[i][j] > 0) {
						flag = 1;
					}
				}
			}

			if (flag == 1) {
				out.println("-1");
				out.close();
				return;
			}

			if (rr.size() + cc.size() <= rr2.size() + cc2.size()) {
				out.println(rr.size() + cc.size());
				for (int i = 0; i < rr.size(); i++) {
					out.println("row " + rr.get(i));
				}
				for (int i = 0; i < cc.size(); i++) {
					out.println("col " + cc.get(i));
				}
			} else {
				out.println(rr2.size() + cc2.size());
				for (int i = 0; i < rr2.size(); i++) {
					out.println("row " + rr2.get(i));
				}
				for (int i = 0; i < cc2.size(); i++) {
					out.println("col " + cc2.get(i));
				}

			}

		}
		out.close();

	}

	static void rand(long a[]) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			Random r = new Random();
			int j = r.nextInt(n);
			long temp = a[j];
			a[j] = a[i];
			a[i] = temp;
		}

	}

	static long mp(long a, long b) {
		long ans = 1;

		while (b != 0) {
			if (b % 2 == 1)
				ans = (ans * a) % MOD;

			a = (a * a) % MOD;
			b /= 2;

		}
		return ans % MOD;
	}

	static class Pair implements Comparable<Pair> {
		int d;
		int i;

		Pair(int rr, int hh) {
			d = rr;
			i = hh;
		}

		public int hashCode() {
			int hu = (int) (d ^ (d >>> 32));
			int hv = (int) (i ^ (i >>> 32));
			return 31 * hu + hv;
		}

		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return (d == other.d && i == other.i);
		}

		@Override
		public int compareTo(Pair edge) {
			if (this.d != edge.d) {
				return Integer.compare(this.d, edge.d);
			} else {
				return Integer.compare(this.i, edge.i);

			}
		}

	}

	static class Node implements Comparable<Node> {
		long x;
		long y;

		public Node(long i, long j) {
			x = i;
			y = j;
		}

		public int compareTo(Node p) {
			return Long.compare(this.y, p.y);
		}

	}

	static class InputReader {

		private InputStream stream;
		private byte[] buf = new byte[8192];
		private int curChar;
		private int snumChars;
		private SpaceCharFilter filter;

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

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}

			int res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}

			long res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));

			return res * sgn;
		}

		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}