#pragma GCC optimize(2)
/*
ID: Victor Chen [mail_vi1]
PROG: Soccer Stadium
LANG: C++
*/

#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <cassert>

using namespace std;

const int Maxn = 2000;

typedef long long ll;

map<ll, bool> hash_mp;
map<ll, int> dp;

map<ll, bool> proc;

int n, ans;
bool mp[Maxn+10][Maxn+10];
int pre[Maxn+10][Maxn+10];

// int dp[Maxn+10][Maxn+10];

struct Rectangle
{
    int x, y; // The id signifies the rectangle.
    int l, r; // The left bound and the right bound.
    int u, d; // The upper bound and the lower bound.

    ll hsh;

    Rectangle(){}
    Rectangle(int x1, int y1, int x2, int y2)
    {
        u = x1; d = x2;
        l = y1; r = y2;
    }

    int find_area()
    {
        return (r-l+1) * (d-u+1);
    }

    void getHash()
    {
        hsh = (((((ll)l*Maxn)+r)*Maxn)+u)*Maxn+d;
    }
    bool exist()
    {
        return l != 0;
    }

    void print()
    {
        printf("%d %d %d %d\n", u, l, d, r);
    }
    void print(int x)
    {
        printf("%d %d %d %d: %d\n", u, l, d, r, x);
    }
}rec[Maxn+10][Maxn+10];

int cnt;
Rectangle ord[Maxn*Maxn+10];
map<int, Rectangle> mp_find_rect, mp_find_rect_up, mp_find_rect_down;

bool cmp(Rectangle x, Rectangle y)
{
    if(x.d-x.u != y.d-y.u)
        return (x.d-x.u) < (y.d-y.u);
    else
        return (x.r-x.l) > (y.r-y.l);
}

Rectangle merge(Rectangle x, Rectangle y)
{
    return Rectangle(max(x.u, y.u), max(x.l, y.l), min(x.d, y.d), min(x.r, y.r));
}

int find_sum(int x1, int y1, int x2, int y2)
{
    return pre[x2][y2] - pre[x2][y1-1] - pre[x1-1][y2] + pre[x1-1][y1-1]; 
}

Rectangle find_rect(int x, int y, int k)
{
    int h = x * (Maxn + 10) * (Maxn + 10)+ y * (Maxn + 10) + k;
    if(mp_find_rect.find(k) != mp_find_rect.end()) {return mp_find_rect[k];}
    Rectangle ret = Rectangle();

    ret.u = x, ret.d = k;

    ret.l = ret.r = y;
    int l = 1, r = y, mid;
    while(l <= r)
    {
        mid = (l+r)/2;
        if(find_sum(x, mid, k, y) == 0)
        {
            r = mid - 1;
            ret.l = mid;
        }
        else
            l = mid + 1;
    }

    l = y, r = n;
    while(l <= r)
    {
        mid = (l+r)/2;
        if(find_sum(x, y, k, mid) == 0)
        {
            l = mid + 1;
            ret.r = mid;
        }
        else
            r = mid - 1;
    }
    mp_find_rect[h] = ret;
    return ret;
}

Rectangle find_up_rect(int x, int y, int k)
{   int h = x * (Maxn + 10) * (Maxn + 10)+ y * (Maxn + 10) + k;
    if(mp_find_rect_up.find(k) != mp_find_rect_up.end()) {return mp_find_rect_up[k];}
    Rectangle ret;

    ret.l = x, ret.r = y, ret.u = ret.d = k;

    int l = 1, r = k, mid;
    while(l <= r)
    {
        mid = (l+r)/2;
        if(find_sum(mid, x, k, y) == 0)
        {
            r = mid - 1;
            ret.u = mid;
        }
        else
            l = mid + 1;
    }
mp_find_rect_up[h] = ret;
    return ret;
}
Rectangle find_down_rect(int x, int y, int k)
{int h = x * (Maxn + 10) * (Maxn + 10)+ y * (Maxn + 10) + k;
    if(mp_find_rect_down.find(k) != mp_find_rect_down.end()) {return mp_find_rect_down[k];}
    Rectangle ret;

    ret.l = x, ret.r = y, ret.u = ret.d = k;

    int l = k, r = n, mid;
    while(l <= r)
    {
        mid = (l+r)/2;
        if(find_sum(k, x, mid, y) == 0)
        {
            l = mid + 1;
            ret.d = mid;
        }
        else
            r = mid - 1;
    }
mp_find_rect_down[h] = ret;
    return ret;
}

int tp;
int nxt[Maxn+10][Maxn+10];
int prv[Maxn+10][Maxn+10];

int biggest_stadium(int N, vector<vector<int>> F)
{
    n = N;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
        {
            mp[i][j] = F[i-1][j-1];
            pre[i][j] = pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1] + mp[i][j];
        }

    for(int i=1; i<=n; i++)
    {
        int lst0 = n+1, lst1 = n+1;
        for(int j=n; j>=1; j--)
            if(mp[i][j] == 0)
            {
                nxt[i][j] = lst1;
                lst0 = j;
            }
            else
            {
                nxt[i][j] = lst0;
                lst1 = j;
            }
    }
    for(int i=1; i<=n; i++)
    {
        int pre0 = 0, pre1 = 0;
        for(int j=1; j<=n; j++)
            if(mp[i][j] == 0)
            {
                prv[i][j] = pre1;
                pre0 = j;
            }
            else
            {
                prv[i][j] = pre0;
                pre1 = j;
            }
    }

    // The columns.
    for(int i=1; i<=n; i++)
    {
        tp = 0;
        for(int j=1; j<=n; j++)
            if(mp[j][i] == 1)
                tp = j;
            else
            {
                rec[i][j] = find_rect(tp+1, i, j);
                rec[i][j].x = i, rec[i][j].y = j;

                rec[i][j].getHash();

                if(rec[i][j].exist())
                {
                    ord[++cnt] = rec[i][j];
                    // hash_mp[rec[i][j].hsh] = true;

                    ord[cnt].getHash();
                }
            }
    }

    // find_rect(1, 2, 4).print();
    
    // for(int i=1; i<=n; i++)
    //     for(int j=1; j<=n; j++)
    //         rec[i][j].print();

    int tot = 0;

    // rec[4][3].print();
    // rec[3][3].print();
    // find_rect(1, 3, 3).print();

    // assert(n != 2000 || pre[n][n] <= 1);
    assert(cnt > Maxn * Maxn);
    sort(ord+1, ord+cnt+1, cmp);
    for(int i=1; i<=cnt; i++)
    {
        // ord[i].print();

        dp[ord[i].hsh] = max(dp[ord[i].hsh], ord[i].find_area());

        if(ord[i].u != 1)
        {
            if(ord[i].x != ord[i].l && mp[ord[i].u-1][ord[i].x-1] == 0)
            {
                int ed = ord[i].x-1;
                int bg = prv[ord[i].u-1][ed] + 1;

                if(bg < ord[i].l) bg = ord[i].l;

                Rectangle nw = find_up_rect(bg, ed, ord[i].d);
                nw.getHash();

                dp[nw.hsh] = max(dp[nw.hsh], dp[ord[i].hsh] + nw.find_area() - merge(ord[i], nw).find_area());
            }
            if(ord[i].x != ord[i].r && mp[ord[i].u-1][ord[i].x+1] == 0)
            {
                int bg = ord[i].x+1;
                int ed = nxt[ord[i].u-1][bg] - 1;

                if(ed > ord[i].r) ed = ord[i].r;

                Rectangle nw = find_up_rect(bg, ed, ord[i].d);
                nw.getHash();
                
                dp[nw.hsh] = max(dp[nw.hsh], dp[ord[i].hsh] + nw.find_area() - merge(ord[i], nw).find_area());
            }
        }
        if(ord[i].d != n && mp[ord[i].d+1][ord[i].x] == 0)
        {
            Rectangle nw = rec[ord[i].x][ord[i].d+1];
            nw.getHash();
            dp[nw.hsh] = max(dp[nw.hsh], dp[ord[i].hsh] + nw.find_area() - merge(ord[i], nw).find_area());
        }

        ans = max(ans, dp[ord[i].hsh]);
    }

    // for(int i=1; i<=cnt; i++)
    //     ord[i].print(dp[ord[i].hsh]);

    return ans;
}

// int N;
// vector<int> ept;
// vector<vector<int>> F;

// int main()
// {
//     freopen("read.in", "r", stdin);

//     scanf("%d", &N);
//     for(int i=0; i<N; i++)
//     {
//         F.push_back(ept);
//         for(int j=0; j<N; j++)
//         {
//             int x;
//             scanf("%d", &x);
//             F[i].push_back(x);
//         }
//     }

//     printf("%d\n", biggest_stadium(N, F));

//     return 0;
// }