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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbs(string str, T t) {
  cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... second) {
  int idx = str.find(',');
  cerr << str.substr(0, idx) << " : " << t << ",";
  dbs(str.substr(idx + 1), second...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
  return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
  os << "[ ";
  for (auto& it : p) os << it << " ";
  return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
  os << "[ ";
  for (auto& it : p) os << it << " ";
  return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
  os << "[ ";
  for (auto& it : p) os << it << " ";
  return os << "]";
}
template <class T>
void prc(T a, T b) {
  cerr << "[";
  for (T i = a; i != b; ++i) {
    if (i != a) cerr << ", ";
    cerr << *i;
  }
  cerr << "]\n";
}
vector<vector<vector<int> > > D;
int V[101][101];
int main() {
  int n, m;
  scanf("%d%d", &n, &m);
  for (int(i) = (int)(1); (i) <= (int)(n); (i)++) {
    for (int(j) = (int)(1); (j) <= (int)(m); (j)++) scanf("%d", &V[i][j]);
  }
  D.resize(n + 1, vector<vector<int> >(m + 1, vector<int>(501, 0)));
  int mini = V[1][1];
  for (int(i) = (int)(1); (i) <= (int)(m); (i)++) {
    mini = min(V[1][i], mini);
    for (int(j) = (int)(0); (j) <= (int)(mini); (j)++) {
      D[1][i][j] = 1;
    }
  }
  for (int(i) = (int)(2); (i) <= (int)(n); (i)++) {
    for (int(k) = (int)(0); (k) <= (int)(500); (k)++) {
      if (D[i - 1][1][k]) {
        int vv = V[i - 1][1] - k;
        if (vv <= V[i][1]) D[i][1][V[i][1] - vv] = 1;
      }
    }
  }
  for (int(i) = (int)(2); (i) <= (int)(n); (i)++) {
    for (int(j) = (int)(2); (j) <= (int)(m); (j)++) {
      for (int(k) = (int)(0); (k) <= (int)(V[i - 1][j]); (k)++) {
        if (D[i - 1][j][k]) {
          bool R = true;
          int vv = V[i][j] - V[i - 1][j] + k;
          if (vv <= V[i][j] && vv >= 0)
            for (int u = 1; u <= m - 1; u++) {
              int col = V[i - 1][u] - k;
              int row = V[i][u] - col;
              if (row != vv) {
                R = false;
                break;
              }
            }
          else
            R = false;
          if (R) D[i][j][vv] = 1;
        }
      }
    }
  }
  int vv = 1000000007;
  int r;
  for (int(i) = (int)(0); (i) <= (int)(500); (i)++) {
    int count = 0;
    if (D[n][m][i]) {
      count += i;
      int col = V[n][m] - i;
      for (int j = n - 1; j >= 1; j--) {
        int row = V[j][m] - col;
        count += row;
      }
      for (int(j) = (int)(1); (j) <= (int)(m); (j)++) count += (V[n][j] - i);
    } else
      count = 1000000007;
    if (count < vv) {
      r = i;
      vv = count;
    }
  }
  if (vv == 1000000007) {
    printf("-1\n");
    return 0;
  }
  printf("%d\n", vv);
  int col = V[n][m] - r;
  for (int(i) = (int)(1); (i) <= (int)(r); (i)++) printf("row %d\n", n);
  for (int j = n - 1; j >= 1; j--) {
    int row = V[j][m] - col;
    for (int(i) = (int)(1); (i) <= (int)(row); (i)++) printf("row %d\n", j);
  }
  for (int(j) = (int)(1); (j) <= (int)(m); (j)++) {
    for (int(i) = (int)(1); (i) <= (int)(V[n][j] - r); (i)++)
      printf("col %d\n", j);
  }
  return 0;
}