#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
#include <experimental/iterator>
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

int64_t comb(int64_t a, int64_t b) {
  if (a < b)
    return 0;
  b = min(b, a - b);
  int64_t ans = 1;
  for (int i = 0; i < b; ++i)
    ans *= a - i;
  for (int i = 1; i <= b; ++i)
    ans /= i;
  return ans;
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n;
  while (cin >> n) {
    vector<string> a(n);
    for (auto &ai : a)
      cin >> ai;
    vector<bitset<1000>> g(n);
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < n; ++j) {
        g[i][j] = a[i][j] - '0';
      }
    }
    vector<int64_t> d(n);
    for (int i = 0; i < n; ++i)
      d[i] = int(g[i].count());
    vector<vector<int64_t>> intersect(n, vector<int64_t>(n, 0));
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j)
        intersect[i][j] = (g[i] & g[j]).count();

    auto Count1 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
          if (not g[i][j])
            continue;
          ans += (d[i] - 1) * (d[j] - 1);
          ans -= intersect[i][j];
        }
      }
      return ans;
    };
    auto Count2 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i)
        ans += comb(d[i], 2);
      return ans;
    };
    auto Count3 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i)
        ans += d[i];
      assert(ans % 2 == 0);
      return ans / 2;
    };
    auto Count4 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i)
        ans += comb(d[i], 3);
      return ans;
    };
    auto Count5 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j)
          if (g[i][j])
            ans += intersect[i][j];
      assert(ans % 3 == 0);
      return ans / 3;
    };
    auto Count7 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
          if (not g[i][j])
            continue;
          ans += comb(intersect[i][j], 2);
        }
      }
      return ans;
    };
    auto Count6 = [&] {
      int64_t ans = 0;
      vector<int64_t> count(n);
      for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
          if (not g[i][j])
            continue;
          count[i] += intersect[i][j];
          count[j] += intersect[i][j];
        }
      }
      for (int i = 0; i < n; ++i)
        ans += comb(count[i] / 2, 2);
      return ans - Count7() * 2;
    };
    auto Count8 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j)
          ans += comb(intersect[i][j], 2);
      assert(ans % 2 == 0);
      return ans / 2;
    };
    auto Count9 = [&] {
      int64_t ans = 0;
      for (int i = 0; i < n; ++i) {
        if (d[i] < 3)
          continue;
        for (int j = 0; j < n; ++j) {
          if (i == j)
            continue;
          int64_t cur = comb(intersect[i][j], 2);
          ans += cur * (d[i] - 2 - g[i][j]);
        }
      }
      return ans;
    };

    int64_t ans = 0;
    ans += 6 * Count1();
    ans += 12 * Count2();
    ans += 2 * Count3();
    ans += 12 * Count4();
    ans += 24 * Count5();
    ans += 24 * Count6();
    ans += 36 * Count7();
    ans += 48 * Count8();
    ans += 12 * Count9();
    cout << ans << '\n';
  }
  return 0;
}