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 = 505;

int n;
char buf[N];
int a[N][N];
int row[N][N];
int L[2][N][N];
int R[2][N][N];

void del(int x,int y) {
	if (x > 0 && x <= n && y > 0 && y <= n && a[x][y]) {
		if (x == 1 || a[x - 1][y] == 0) {
			if (y == 1 || a[x][y - 1] == 0) {
				for (int i = y; i <= n; ++i) {
					row[x][i] -= a[x][y];
				}
				a[x][y] = 0;
				del(x + 1, y);
				del(x, y + 1);
			}
		}
	}
}

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


	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			row[i][j] = row[i][j - 1] + a[i][j];
		}
	}
	
	long long ans = 0;
	memset(L, 69, sizeof L);
	for (int i = n; i > 0; --i) {
		for (int j = n; j > 0; --j) {
			if (a[i][j] == 0) {
				continue;
			}
			L[1][j][i] = j;
			R[1][j][i] = j;
			if (i < n && a[i + 1][j]) {
				for (int k = i + 1; k <= n; ++k) {
					L[1][j][k] = min(L[1][j][k], L[0][j][k]);
					R[1][j][k] = max(R[1][j][k], R[0][j][k]);
				}
			}
			if (j < n && a[i][j + 1]) {
				for (int k = i; k <= n; ++k) {
					L[1][j][k] = min(L[1][j][k], L[1][j + 1][k]);
					R[1][j][k] = max(R[1][j][k], R[1][j + 1][k]);
				}
			}
			int val = 0;
			for (int k = i; k <= n; ++k) {
				if (L[1][j][k] <= R[1][j][k]) {
					val += row[k][R[1][j][k]] - row[k][L[1][j][k] - 1];
				}
			}
			ans += (long long) (a[i][j]) * (val - a[i][j]);
			del(i, j);
		}
		for (int j = 1; j <= n; ++j) {
			for (int k = i; k <= n; ++k) {
				L[0][j][k] = L[1][j][k];
				R[0][j][k] = R[1][j][k];
				L[1][j][k] = 1e9;
				R[1][j][k] = 0;
			}
		}
	}
	
	printf("%lld\n", ans);
}