int dx[]={1,1,1,0,0,-1,-1,-1}, dy[]={0,-1,1,1,-1,0,-1,1};
int dx2[]={1,0,-1,0}, dy2[]={0,1,0,-1};
int n, g[MX][MX], m[MX*MX];
bool c[MX][MX];
vector<pair<int, pi>> ev;
ll ret=0;
/*
CHANGES MY MAP TO INT FOR SPEEDUP
10/21 wo
 */

bool side(int x, int y){
    return (x==0 || y==0 || x==n-1 || y==n-1);
}
bool leg(int x, int y){
    return (x>=0 && x<=n-1 && y>=0 && y<=n-1);
}

int tr(int x, int y){
    return x*n+y;
}
pi r(int x){
    return mp(x/n,x%n);
}
struct DSU{
    int n;
    vi p, mx;
    void init(int N){
        n=N;
        p=vi(n,-1);
        mx=vi(n,0);
    }
    int get(int x){
        return (p[x]<0)?x:p[x]=get(p[x]);
    }
    bool same(int x, int y){
        return get(x)==get(y);
    }
    bool unite(int x, int y){
        x=get(x), y=get(y);
        if(x==y)return false;
        if(y==0 || (x!=0 && p[y]<p[x]))swap(x,y);
        p[x]+=p[y];
        p[y]=x;
        ckmax(mx[x],mx[y]);
        return true;
    }
};

DSU dsu;
int main() {
    setIO("valleys");
    cin >> n;
    dsu.init(MX*MX);
    For(i,n){
        For(j,n){
            cin>> g[i][j];
            ev.pb(mp(g[i][j],mp(i,j)));
        }
    }
    sort(all(ev));
    reverse(all(ev));
    trav(x,ev){//FIND MAX HOLE wrong here?
        queue<pi> q;
        if(side(x.s.f,x.s.s)){
            q.push(x.s);
        }
        else{
            For(k,8){
                int nx=x.s.f+dx[k], ny=x.s.s+dy[k];//DECR, which ones need me
                if(leg(nx,ny) && c[nx][ny]){
                    q.push(x.s);
                    break;
                }
            }
        }
        while(sz(q)){
            pi y=q.front(); q.pop();
            int tx=y.f, ty=y.s;
            if(!c[tx][ty]){
                ckmax(m[tr(x.s.f,x.s.s)],g[tx][ty]);//here?
                c[tx][ty]=true;
                For(k,8){
                    int nx=tx+dx[k], ny=ty+dy[k];//DECR, which ones need me
                    if(leg(nx,ny) && g[nx][ny]>g[x.s.f][x.s.s] && !c[nx][ny])
                        q.push(mp(nx,ny));
                }
            }
        }
    }
    reverse(all(ev));
    trav(x,ev){
        int cx=x.s.f,cy=x.s.s;
        For(k,4){
            int tx=cx+dx2[k], ty=cy+dy2[k];
            if(leg(tx,ty) && g[tx][ty]<g[cx][cy])//already processed
                dsu.unite(tr(tx,ty),tr(cx,cy));
        }
        ckmax(dsu.mx[dsu.get(tr(cx,cy))],m[tr(cx,cy)]);

        if(g[cx][cy]>=dsu.mx[dsu.get(tr(cx,cy))])//no hole to worry abt
            dsu.mx[dsu.get(tr(cx,cy))]=-1;

        if(dsu.mx[dsu.get(tr(cx,cy))]<=0){
            ret+=-dsu.p[dsu.get(tr(cx,cy))];
        }
        // else dbg("HI",dsu.mx[dsu.get(tr(cx,cy))],cx,cy);
    }
    cout << ret << nl;
    dbg(ret);
}
            // c[x.s.f][x.s.s]=true;
            // For(k,8){
            //  int tx=x.s.f+dx[k], ty=x.s.s+dy[k];
            //  if(leg(tx, ty) && g[tx][ty]>g[x.s.f][x.s.s] && !c[tx][ty])
            //      q.push(mp(tx,ty));
            // }