// author : thembululquaUwU
// 3.9.2024

#include <bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
#define endl '\n'

using namespace std;
using ll = long long;
using ii = pair <int, int>;
using vi = vector <int>;

const int MaxN = 2e5;
const int mod = 1e9 + 7;

void maxl(auto &a, auto b) {a = max(a, b);}
void minl(auto &a, auto b) {a = min(a, b);}

template <int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
    static_assert(D >= 1, "Dimension must be positive");
    template <typename... Args>
    Vec(int n = 0, Args... args) : vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {}
};

template <typename T>
struct Vec<1, T> : public vector<T> {
    Vec(int n = 0, T val = T()) : std::vector<T>(n, val) {}
};

int biggest_stadium(int n, vector <vi> f){
    if (n > 30){
        int ans = 0;
        vi l(n, -1), r(n, -1);
        int st = -1, ed = n, gg = 0;
        for (int i = 0; i < n; ++ i){
            //cout << i << endl;
            int nt = 0;
            for (int j = 0; j < n; ++ j) {
                if (!f[i][j]){
                    if (l[i] == -1) l[i] = j;
                    r[i] = j; ++ ans; gg = 1;
                    if (st == -1) st = i; if (i > ed) return 0;
                    if (nt) return 0;
                }
                else if (l[i] != -1) nt = 1;
            }
            if (l[i] == -1 && gg && ed == n) ed = i;
        }
        for (int i = st; i < ed; ++ i){
            for (int j = i + 1; j < ed; ++ j){
                if (l[i] <= l[j] && r[j] <= r[i]) continue;
                if (l[j] <= l[i] && r[i] <= r[j]) continue;
                return 0;
            }
        }
        int h = 0;
        for (int i = st + 1; i < ed; ++ i){
            int j = i - 1;
                if (l[i] <= l[j] && r[j] <= r[i] && h == 0) continue;
                h = 1;
                if (l[j] <= l[i] && r[i] <= r[j] && h == 1) continue;
                return 0;
        }

        return ans;
    }

    Vec <3, bool> used(n, n, n);
    Vec <4, int> dp(n, n, n, n);
    for (int i = 0; i < n; ++ i){
        for (int l = 0; l < n; ++ l){
            for (int r = l; r < n; ++ r) {
                if (f[i][r]) break;
                used[i][l][r] = 1;
                dp[i][i][l][r] = r - l + 1;
            }
        }
    }

    int ans = 0;

    for (int l = n - 1; l >= 0; -- l){
        for (int r = l; r < n; ++ r){
            for (int u = 0; u < n; ++ u){
                for (int v = u; v < n; ++ v) if (dp[l][r][u][v]){
                    maxl(ans, dp[l][r][u][v]);
                    for (int nu = u; nu <= v; ++ nu){
                        for (int nv = nu; nv <= v; ++ nv){
                            if (l && used[l - 1][nu][nv]) maxl(dp[l - 1][r][nu][nv], dp[l][r][u][v] + nv - nu + 1);
                            if (r < n - 1 && used[r + 1][nu][nv]) maxl(dp[l][r + 1][nu][nv], dp[l][r][u][v] + nv - nu + 1);
                        }
                    }
                }
            }
        }
    }

    return ans;

}