#include <bits/stdc++.h>
using namespace std;
const int Dx[] = {0, 1, 0, -1};
const int Dy[] = {1, 0, -1, 0};
const int Ex[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int Ey[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int maxn = 2100;
int n, A[maxn][maxn];
struct Tpair {
  int x, y;
  Tpair(int _x = 0, int _y = 0) { x = _x, y = _y; }
  inline bool operator<(const Tpair &b) const {
    return x != b.x ? x < b.x : y < b.y;
  }
  inline bool operator!=(const Tpair &b) const { return x != b.x || y != b.y; }
};
inline double sqr(double x) { return x * x; }
inline int dist(const Tpair &a, const Tpair &b) {
  return sqr(a.x - b.x) + sqr(a.y - b.y);
}
namespace Ninit {
void init() {
  int i, j;
  scanf("%d", &n);
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j) scanf("%d", A[i] + j);
}
}  // namespace Ninit
namespace Nsolve {
int N1, N2;
int T1, T2, T3, T4;
namespace Nsmooth {
void solve() {
  int i, j, k, x;
  Tpair u, v;
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j) {
      u = Tpair(i, j);
      for (x = 0, k = 0; k < 8; ++k) {
        v = Tpair(u.x + Ex[k], u.y + Ey[k]);
        if (v.x < 0 || v.y < 0 || v.x >= n || v.y >= n) continue;
        if (A[u.x][u.y] == A[v.x][v.y]) ++x;
      }
      if (x < 4) A[i][j] = 1 - A[i][j];
    }
}
}  // namespace Nsmooth
namespace Nfloor {
Tpair H[maxn * maxn];
bool U[maxn][maxn];
void bfs(int _x, int _y) {
  int i, j, l, r, k;
  Tpair u, v;
  H[1] = Tpair(_x, _y), U[_x][_y] = true;
  for (l = 0, r = 1; l++ != r;) {
    u = H[l];
    for (k = 0; k < 4; ++k) {
      v = Tpair(u.x + Dx[k], u.y + Dy[k]);
      if (v.x < 0 || v.y < 0 || v.x >= n || v.y >= n || !A[v.x][v.y] ||
          U[v.x][v.y])
        continue;
      H[++r] = v, U[v.x][v.y] = true;
    }
  }
  if (r < 70) return;
  double Si = r, Cx = 0, Cy = 0, Ri = 0;
  for (i = 1; i <= r; ++i) Cx += H[i].x, Cy += H[i].y;
  Cx /= r, Cy /= r;
  for (i = 1; i <= r; ++i) Ri = max(Ri, sqr(H[i].x - Cx) + sqr(H[i].y - Cy));
  Si / Ri > 2.54 ? ++N1 : ++N2;
}
void solve() {
  int i, j;
  memset(U, 0, sizeof U);
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j)
      if (A[i][j] && !U[i][j]) bfs(i, j);
}
}  // namespace Nfloor
void solve() {
  int i;
  for (i = 0; i < 5; ++i) Nsmooth::solve();
  Nfloor::solve();
  cout << N1 << ' ' << N2 << endl;
}
}  // namespace Nsolve
int main() {
  Ninit::init();
  Nsolve::solve();
  return 0;
}
