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

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;
using ull = uint64_t;

template <class F>
struct ycr {
	F f;
	
	template <class T>
	explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... Args>
	decltype(auto) operator()(Args&&... args) {
		return f(ref(*this), forward<Args>(args)...);
	}
};
template <class F>
decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

// Reference: https://judge.yosupo.jp/submission/76542
// NOT INITIALISED BY DEFAULT! call .clear to zero all bits
template<int N>
class Bitset {
	private:
		constexpr static ull LM = (1ull<<32) - 1;
		constexpr static ull FM = ~0ull;
		constexpr static int H = (N + 63) >> 6;
		array<ull, H> bits;

		void clearHighBits() {
			if constexpr (N & 63) bits[H-1] &= ~(FM << (N & 63));
		}
	public:
		Bitset() {}

		void clear() { for (ull& v : bits) v = 0; }
		void set() {
			for (ull& v : bits) v = FM;
			clearHighBits();
		}
		void flip() {
			for (ull& v : bits) v = ~v;
			clearHighBits();
		}
		bool get(int i) const { return bits[i>>6] & (1ull << (i & 63)); }
		void set(int i, ull v) { bits[i>>6] = (bits[i>>6] & ~(1ull << (i & 63))) | (v << (i & 63)); }
		void setZero(int i) { bits[i>>6] &= ~(1ull << (i & 63)); }
		void setOne(int i) { bits[i>>6] |= 1ull << (i & 63); }
		
		// Sets bit[a + i] = v[i] for i \in [0, b-a]. Must have 0 <= a <= b < min(a + 64, N)
		void setRange(int a, int b, ull v) {
			int j = (a >> 6), r = (a & 63), len = b-a+1;
			ull mask = FM >> (64 - len);
			bits[j] = (bits[j] & ~(mask << r)) | (v << r);
			if ((b >> 6) > j) bits[j + 1] = (bits[j + 1] & ~(mask >> (64 - r))) | (v >> (64 - r));
		}

		// Returns v s.t. v[i] = bit[a + i] for i \in [0, b-a]. Must have 0 <= a <= b < min(a + 64, N)
		ull getRange(int a, int b) const {
			int j = (a >> 6), r = (a & 63), len = b-a+1;
			ull mask = FM >> (64 - len);
			if ((b >> 6) <= j) return (bits[j] >> r) & mask;
			return ((bits[j] >> r) | (bits[j+1] << (64 - r))) & mask;
		}

		// Returns minimum i \in [a, b] such that bits[i] = 1, or b + 1 if none exist
		int findNext(int a, int b = N-1) const {
			if (a > b) return b + 1;

			int j = (a >> 6);
			ull tmp = bits[j] >> (a & 63);
			if (tmp != 0) return min(b + 1, a + __builtin_ctzll(tmp));
			for (++j; (j << 6) <= b; ++j) {
				if (bits[j]) return min(b + 1, (j << 6) + __builtin_ctzll(bits[j]));
			}
			return b + 1;
		}

		// Returns maximum i \in [a, b] such that bits[i] = 1, or a - 1 if none exist
		int findPrev(int b, int a = 0) const {
			if (b < a) return a - 1;

			int j = (b >> 6);
			ull tmp = bits[j] << (63 - (b & 63));
			if (tmp != 0) return max(a - 1, b - __builtin_clzll(tmp));
			for (--j; ((j + 1) << 6) > a; --j) {
				if (bits[j]) return max(a - 1, (j << 6) + 63 - __builtin_clzll(bits[j]));
			}
			return a - 1;
		}
		
		// Counts set bits in range [a, b]
		int count(int a = 0, int b = N-1) const {
			int res = 0;
			if (a & 63) res -= __builtin_popcountll(bits[a >> 6] << (64 - (a & 63)));
			if ((b + 1) & 63) res -= __builtin_popcountll(bits[b >> 6] >> ((b + 1) & 63));
			for (int j = (a >> 6); j <= (b >> 6); ++j) res += __builtin_popcountll(bits[j]);
			return res;
		}

		bool operator==(const Bitset<N>& rhs) const {
			for (int i = 0; i < H; ++i) {
				if (bits[i] != rhs.bits[i]) return false;
			}
			return true;
		}
		bool operator<(const Bitset<N>& rhs) const {
			for (int i = 0; i < H; ++i) {
				if (bits[i] != rhs.bits[i]) return bits[i] < rhs.bits[i];
			}
			return false;
		}
		Bitset<N> operator~() const {
			Bitset<N> res;
			for (int i = 0; i < H; ++i) res.bits[i] = ~bits[i];
			res.clearHighBits();
			return res;
		}
		Bitset<N> operator<<(int d) const {
			Bitset<N> res;
			int s = min(d >> 6, H);
			int r = d & 63;
			for (int i = 0; i < s; ++i) res.bits[i] = 0;
			if (r == 0) for (int i = s; i < H; ++i) res.bits[i] = bits[i - s];
			else {
				if (s < H) res.bits[s] = bits[0] << r;
				for (int i = s + 1; i < H; ++i) res.bits[i] = (bits[i - s] << r) | (bits[i-1 - s] >> (64 - r));
			}
			res.clearHighBits();
			return res;
		}
		Bitset<N> operator>>(int d) const {
			Bitset<N> res;
			int s = min(d >> 6, H);
			int r = d & 63;
			for (int i = H-1; i >= H-s; ++i) res.bits[i] = 0;
			if (r == 0) for (int i = H-1-s; i >= 0; --i) res.bits[i] = bits[i + s];
			else {
				if (s < H) res.bits[H-1-s] = bits[H-1] >> r;
				for (int i = H-2-s; i >= 0; --i) res.bits[i] = (bits[i + s] >> r) | (bits[i+1 + s] << (64 - r));
			}
			return res;
		}
		Bitset<N> operator|(const Bitset& rhs) const {
			Bitset<N> res;
			for (int i = 0; i < H; ++i) res.bits[i] = bits[i] | rhs.bits[i];
			return res;
		}
		Bitset<N> operator&(const Bitset& rhs) const {
			Bitset<N> res;
			for (int i = 0; i < H; ++i) res.bits[i] = bits[i] & rhs.bits[i];
			return res;
		}
		Bitset<N> operator^(const Bitset& rhs) const {
			Bitset<N> res;
			for (int i = 0; i < H; ++i) res.bits[i] = bits[i] ^ rhs.bits[i];
			return res;
		}
		Bitset operator+(const Bitset& rhs) const {
			Bitset<N> res;
			uint8_t carry = 0;
			for (int i = H-1; i >= 0; --i) carry = _addcarry_u64(carry, bits[i], rhs.bits[i], res.bits[i]);
			return res;
		}
		Bitset operator-(const Bitset& rhs) const {
			Bitset<N> res;
			uint8_t borrow = 0;
			for (int i = H-1; i >= 0; --i) borrow = _subborrow_u64(borrow, bits[i], rhs.bits[i], res.bits[i]);
			return res;
		}
};

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	int N; cin >> N;

	constexpr int L = 2048;
	//using bs = bitset<L>;
	using bs = Bitset<L>;
	vector<bs> adj(N);
	for (int i = 0; i < N; i++) {
		string s; cin >> s;
		for (int j = 0; j < N; j++) {
			if (s[j] == '1') adj[i].setOne(j);
			else adj[i].setZero(j);
		}
	}

	ll ans = 0;
	vector<int> bfs; bfs.reserve(N);
	vector<int> dist(N, N);
	for (int st = 0; st < N; st++) {
		bfs.clear();
		bfs.push_back(st);

		fill(dist.begin(), dist.end(), N);
		dist[st] = 0;

		bs todo;
		todo.set();
		todo.setZero(st);

		for (int z = 0; z < int(bfs.size()); z++) {
			const int cur = bfs[z];
			const bs reachable = todo & adj[cur];
			int nxt = 0;
			while (true) {
				nxt = reachable.findNext(nxt);
				if (nxt >= N) break;
				dist[nxt] = dist[cur]+1;
				todo.setZero(nxt);
				bfs.push_back(nxt);
				nxt++;
			}
		}
		for (const int& d : dist) {
			ans += d*d;
		}
	}
	cout << ans << '\n';
}