/*
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];
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.hsh < y.hsh;
}
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)
{
    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;
    }

    return ret;
}

Rectangle find_up_rect(int x, int y, int 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;
    }

    return ret;
}
Rectangle find_down_rect(int x, int y, int 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;
    }

    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();
                }
            }
    }

    int tot = 0;

    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 && ord[i].hsh != ord[i-1].hsh)
        {
            int bg = ord[i].l;
            if(mp[ord[i].u-1][bg] == 1)
                bg = nxt[ord[i].u-1][bg];
            
            int ed = nxt[ord[i].u-1][bg] - 1;
            if(ed >= ord[i].r) ed = ord[i].r;

            while(bg <= 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());

                bg = nxt[ord[i].u-1][ed+1];
                ed = nxt[ord[i].u-1][bg] - 1;
                if(ed >= ord[i].r) ed = ord[i].r;
            }
        }
        if(ord[i].u != n && mp[ord[i].d+1][ord[i].x] == 0)
        {
            Rectangle nw = rec[ord[i].x][ord[i].y+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;
// }