Problem: Problem F and F2 are the same problem, but with different constraints and time limits.

We have a board divided into N horizontal rows and N vertical columns of square cells. The cell at the i-th row from the top and the j-th column from the left is called Cell (i,j). Each cell is either empty or occupied by an obstacle. Also, each empty cell has a digit written on it. If A_{i,j}= `1`, `2`, ..., or `9`, Cell (i,j) is empty and the digit A_{i,j} is written on it. If A_{i,j}= `#`, Cell (i,j) is occupied by an obstacle.

Cell Y is reachable from cell X when the following conditions are all met:

* Cells X and Y are different.
* Cells X and Y are both empty.
* One can reach from Cell X to Cell Y by repeatedly moving right or down to an adjacent empty cell.



Consider all pairs of cells (X,Y) such that cell Y is reachable from cell X. Find the sum of the products of the digits written on cell X and cell Y for all of those pairs.

Constraints

* 1 \leq N \leq 500
* A_{i,j} is one of the following characters: `1`, `2`, ... `9` and `#`.

Input

Input is given from Standard Input in the following format:


N
A_{1,1}A_{1,2}...A_{1,N}
A_{2,1}A_{2,2}...A_{2,N}
:
A_{N,1}A_{N,2}...A_{N,N}


Output

Print the sum of the products of the digits written on cell X and cell Y for all pairs (X,Y) such that cell Y is reachable from cell X.

Examples

Input

2
11
11


Output

5


Input

4
1111
11#1
1#11
1111


Output

47


Input

10
76##63##3#
8445669721
75#9542133
3#285##445
749632##89
2458##9515
5952578#77
1#3#44196#
4355#99#1#
298#63587


Output

36065


Input

10
4177143673
7#########
5#1716155#
6#4#####5#
2#3#597#6#
6#9#8#3#5#
5#2#899#9#
1#6#####6#
6#5359657#
5#########


Output

6525

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

const int N = 500;
const int oo = 0x3f3f3f3f;

int n;
int a[N + 5][N + 5];
int f[N + 5][N + 5];
char st[N + 5][N + 5];
int L[N + 5][N + 5], R[N + 5][N + 5];

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        scanf("%s", st[i] + 1);
        for(int j = 1; j <= n; ++j) {
            a[i][j] = (st[i][j] == '#') ? 0 : st[i][j] - '0';
        }
    }

    long long ans = 0;
    for(int j = n; j >= 1; --j) if(a[n][j] > 0) {
        L[n][j] = j; 

        if(a[n][j + 1] > 0) {
            f[n][j] = f[n][j + 1];
            R[n][j] = R[n][j + 1];
        } else {
            R[n][j] = j;
        }

        ans += a[n][j] * f[n][j];
        f[n][j] += a[n][j];
    }

    for(int i = n - 1; i >= 1; --i) {
        for(int j = n; j >= 1; --j) if(a[i][j] > 0) {
            bool r = (a[i][j + 1] > 0), d = (a[i + 1][j] > 0);

            if(!r && !d) {
                L[i][j] = R[i][j] = j;
                for(int k = i + 1; k <= n; ++k) L[k][j] = oo, R[k][j] = -oo;
            } else if(r && !d) {
                L[i][j] = j;
                R[i][j] = R[i][j + 1];
                f[i][j] = f[i][j + 1];
                for(int k = i + 1; k <= n; ++k) L[k][j] = L[k][j + 1], R[k][j] = R[k][j + 1];
            } else if(!r && d) {
                f[i][j] = f[i + 1][j];
                L[i][j] = R[i][j] = j;
            } else {
                L[i][j] = j; R[i][j] = R[i][j + 1];
                f[i][j] = f[i + 1][j] + f[i][j + 1];

                int lim = 0;
                for(int k = i + 1; k <= n; ++k) {
                    if(R[k][j] >= L[k][j + 1] && L[k][j + 1] > lim) {
                        f[i][j] -= f[k][L[k][j + 1]];
                    }
                    lim = R[k][j];
                    L[k][j] = min(L[k][j], L[k][j + 1]);
                    R[k][j] = max(R[k][j], R[k][j + 1]);
                }
            }
            
            ans += a[i][j] * f[i][j];
            f[i][j] += a[i][j];
        }
    }
    printf("%lld\n", ans);

    return 0;
}