#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
const int N = 2005;
const int inf = 1e9;
int n, m, k, qq;
int a[N][N], up[N][N], dp[N][N], nxt[N][N];
int prefr[N][N], pref[N][N];
int queryp(int rx, int ry) {
    return (rx < 0 || ry < 0 ? 0 : pref[rx][ry]);
}

int query(int lx, int rx, int ly, int ry) {
    return queryp(rx, ry) - queryp(lx - 1, ry) - queryp(rx, ly - 1) + queryp(lx - 1, ly - 1);
}

pi findup(int rx, int ly, int ry) {
    int l = 0, r = rx, lx = -1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (query(mid, rx, ly, ry)) l = mid + 1;
        else r = mid - 1, lx = mid;
    }
    
    if (lx == 0 || a[lx - 1][ly]) return {lx, ly};
    else return {lx, nxt[lx - 1][ly]};
}

int dfs(int i, int j) {
    if (i == n) return -inf;
    if (dp[i][j] != -1) return dp[i][j];
    int lx = findup(i, j, j).first, rx = i;
    int l = 0, r = j, ly = -1, ry = -1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (query(lx, rx, mid, j)) l = mid + 1;
        else r = mid - 1, ly = mid;
    }
    
    l = j, r = n - 1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (query(lx, rx, j, mid)) r = mid - 1;
        else l = mid + 1, ry = mid;
    }
    
    if (query(lx, rx, ly, ry)) return -inf;
    if (lx == 0) {
        if (j > ly) return dp[i][j] = dp[i][ly];
    }
    
    else {
        int pp = (a[lx - 1][ly] ? ly : nxt[lx - 1][ly]);
        if (pp < j) return dp[i][j] = dp[i][pp];
    }
    
    int szx = rx - lx + 1, szy = ry - ly + 1, cntx = 0;
    dp[i][j] = szx * szy;
    if (lx != 0) {
        int pl = ly, cur = min(ry + 1, (a[lx - 1][ly] ? ly : nxt[lx - 1][ly]));
        while (true) {
            cntx++;
            if (pl < cur) {
                auto [lxx, p] = findup(rx, pl, cur - 1);
                dp[i][j] = max(dp[i][j], dfs(i, p) + szx * (szy - cur + pl));
            }
            
            if (cur == ry + 1) break;
            pl = cur + 1, cur = min(ry + 1, nxt[lx - 1][cur]);
        }
    }
    
    if (rx != n - 1) {
        int pl = ly, cur = min(ry + 1, (a[rx + 1][ly] ? ly : nxt[rx + 1][ly]));
        while (true) {
            cntx++;
            if (pl < cur) {
                auto [lxx, p] = findup(rx + 1, pl, cur - 1);
                dp[i][j] = max(dp[i][j], dfs(i + 1, p) + szx * (szy - cur + pl));
            }
            
            if (cur == ry + 1) break;
            pl = cur + 1, cur = min(ry + 1, nxt[rx + 1][cur]);
        }
    }
    
    return dp[i][j];
}

int biggest_stadium(int NN, std::vector<std::vector<int>> F) {
    n = NN;
    memset(dp, -1, sizeof(dp));
    for (int i = 0; i < n; i++) nxt[i][n] = n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            a[i][j] = F[i][j];
            prefr[i][j] = (j == 0 ? 0 : prefr[i][j - 1]) + a[i][j];
            pref[i][j] = (i == 0 ? 0 : pref[i - 1][j]) + prefr[i][j];
        }
        
        for (int j = n - 1; j >= 0; j--) {
            nxt[i][j] = nxt[i][j + 1];
            if (a[i][j + 1]) nxt[i][j] = j + 1;
        }
    }
    
    int out = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (a[i][j]) continue;
            out = max(out, dfs(i, j));
        }
    }
    
    return out;
}