#include <bits/stdc++.h>

#include "soccer.h"

#if defined(LOCAL)
#define DBG_MACRO_NO_WARNING
#include <dbg.hpp>

#include "grader.cpp"
#else
#define dbg(x...) (0)
#endif

using namespace std;

using ll = long long;

// #define int ll
#define rep(i, f, t) for (int i = (f), ed##i = (t); i <= ed##i; ++i)
#define re(i, t) rep (i, 1, t)
#define per(i, t, f) for (int i = (t), ed##i = (f); i >= ed##i; --i)
#define ste(i, f, t, s) for (int i = (f), ed##i = (t); i <= ed##i; i += s)
#define nxt(i, f, g) for (int i = g.h[f]; i; i = g.e[i].n)
#define umod(x) ((x) >= mo && ((x) -= mo))
#define dmod(x) ((x) < 0 && ((x) += mo))
#define y1 y1__
#define fio(x) (freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout))

template <class T, class E>
__attribute__((always_inline)) inline void up(T &x, E &&y) {
  if (x < y) x = y;
}
template <class T, class E>
__attribute__((always_inline)) inline void down(T &x, E &&y) {
  if (y < x) x = y;
}

namespace qingwa {
const int N = 2009;
int n, a[N][N], L[N][N], R[N][N], dp[N][N];

inline int Work1() {
  int x = -1, y = -1;
  re (i, n)
    re (j, n)
      if (a[i][j]) x = i, y = j;
  down(x, n - x + 1), down(y, n - y + 1);
  return n * n - (x * y);
}

inline bool Ck(pair<int, int> x, pair<int, int> y) {
  return (x.first <= y.first && y.second <= x.second) ||
         (y.first <= x.first && x.second <= y.second);
}

inline int Work2() {
  int sum = 0;
  re (i, n)
    re (j, n) sum += !a[i][j];
  vector<pair<int, int>> vec;
  int cnt = 0;
  re (i, n) {
    int lst = -1;
    re (j, n) {
      if (!a[i][j] && (j == 1 || a[i][j - 1])) {
        if (lst != -1) return 0;
        lst = j;
      }
      if (!a[i][j] && (j == n || a[i][j + 1])) vec.push_back({lst, j});
    }
    if (lst == -1)
      ++cnt;
    else if (cnt)
      return 0;
  }
  rep (i, 0, vec.size() - 1)
    rep (j, i + 1, vec.size() - 1)
      if (!Ck(vec[i], vec[j])) return 0;
  return sum;
}

inline int Main() {
  int cnt = 0;
  re (i, n)
    re (j, n) cnt += a[i][j];
  if (!cnt) return n * n;
  if (cnt == 1) return Work1();
  // return Work2();
  if (n > 500) return Work2();
  memset(dp, ~0x3f, sizeof dp);
  int ans = 0;
  re (ln, n) {
    re (l, n)
      rep (r, l, n) L[l][r] = 1, R[l][r] = n, dp[l][r] = 0;
    re (i, ln)
      re (j, n)
        if (a[i][j]) L[j][j] = i + 1;
    per (i, n, ln)
      re (j, n)
        if (a[i][j]) R[j][j] = i - 1;
    re (len, n)
      re (l, n) {
        int r = l + len - 1;
        if (r > n) break;
        if (l != r)
          L[l][r] = max(L[l + 1][r], L[l][r - 1]), R[l][r] = min(R[l + 1][r], R[l][r - 1]);
        dp[l][r] = (R[l][r] - L[l][r] + 1) * (r - l + 1);
        up(dp[l][r], max(dp[l + 1][r], dp[l][r - 1]) + (R[l][r] - L[l][r] + 1));
        up(ans, dp[l][r]);
      }
  }
  return ans;
}
}  // namespace qingwa

int biggest_stadium(int N, std::vector<std::vector<int>> F) {
  using namespace qingwa;
  n = N;
  rep (i, 0, n - 1)
    rep (j, 0, n - 1) a[i + 1][j + 1] = F[i][j];
  return qingwa::Main();
}