#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int N;

vector<int> to0(vector<string> a, int y0) {
// cerr<<"[to0]"<<endl;for(int x=0;x<N;++x)cerr<<"  "<<a[x]<<endl;
  vector<int> ops;
  auto left = [&](int x) -> void {
    ops.push_back(x);
    rotate(a[x].begin(), a[x].begin() + 1, a[x].end());
// cerr<<"[left] "<<x<<endl;for(int x=0;x<N;++x)cerr<<"  "<<a[x]<<endl;
  };
  auto down = [&](int y) -> void {
    ops.push_back(N + y);
    const char t = a[N - 1][y];
    for (int x = N - 1; --x >= 0; ) a[x + 1][y] = a[x][y];
    a[0][y] = t ^ '0' ^ '1';
// cerr<<"[down] "<<y<<endl;for(int x=0;x<N;++x)cerr<<"  "<<a[x]<<endl;
  };
  for (int x = N; --x >= 0; ) {
   loop:
    for (int y = 0; y < N; ++y) if (y0 != y && a[x][y] == '1') {
      for (; a[x][y0] == '1'; down(y0)) {}
      for (; a[x][y0] == '0'; left(x)) {}
      goto loop;
    }
  }
  const int y1 = y0 ? (y0 - 1) : (N - 1);
  for (int x = 0; x < N; ++x) (a[x][y0] == '1') ? left(x) : down(y1);
  for (int x = 0; x < N; ++x) down(y1);
  return ops;
}

vector<int> to0(const vector<string> &a) {
  auto ret = to0(a, 0);
  for (int y = 1; y < N; ++y) {
    auto res = to0(a, y);
    if (ret.size() > res.size()) ret = res;
  }
  return ret;
}

vector<int> solve(const vector<string> &a, const vector<string> &b) {
  auto opsA = to0(a);
  auto opsB = to0(b);
  reverse(opsB.begin(), opsB.end());
  for (const int op : opsB) {
    if (op < N) {
      opsA.push_back(N - 1 - op);
    } else {
      opsA.push_back(N + (N - 1 - (op - N)));
    }
  }
  return opsA;
}

char A[30][30], B[30][30];

int main() {
  for (; ~scanf("%d", &N); ) {
    for (int x = 0; x < N; ++x) scanf("%s", A[x]);
    for (int x = 0; x < N; ++x) scanf("%s", B[x]);
    
    vector<string> a(N, string(N, '?'));
    vector<string> b(N, string(N, '?'));
    for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) a[x][y] = A[x][y];
    for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) b[x][y] = B[N - 1 - x][N - 1 - y];
    
    const auto ops0 = solve(a, b);
    for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) a[x][y] ^= '0' ^ '1';
    for (int x = 0; x < N; ++x) for (int y = 0; y < N; ++y) b[x][y] ^= '0' ^ '1';
    const auto ops1 = solve(a, b);
cerr<<"|ops0| = "<<ops0.size()<<", |ops1| = "<<ops1.size()<<endl;
    
    const auto ans = (ops0.size() < ops1.size()) ? ops0 : ops1;
    printf("%d\n", (int)ans.size());
    for (const int op : ans) {
      if (op < N) {
        printf("row %d\n", op + 1);
      } else {
        printf("column %d\n", (op - N) + 1);
      }
    }
  }
  return 0;
}