You are given a matrix *f* with 4 rows and *n* columns. Each element of the matrix is either an asterisk (*) or a dot (.).

You may perform the following operation arbitrary number of times: choose a square submatrix of *f* with size *k* × *k* (where 1 ≤ *k* ≤ 4) and replace each element of the chosen submatrix with a dot. Choosing a submatrix of size *k* × *k* costs *a*<sub class="lower-index">*k*</sub> coins.

What is the minimum number of coins you have to pay to replace all asterisks with dots?
The first line contains one integer *n* (4 ≤ *n* ≤ 1000) — the number of columns in *f*.

The second line contains 4 integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, *a*<sub class="lower-index">3</sub>, *a*<sub class="lower-index">4</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 1000) — the cost to replace the square submatrix of size 1 × 1, 2 × 2, 3 × 3 or 4 × 4, respectively.

Then four lines follow, each containing *n* characters and denoting a row of matrix *f*. Each character is either a dot or an asterisk.
In the first example you can spend 8 coins to replace the submatrix 3 × 3 in the top-left corner, and 1 coin to replace the 1 × 1 submatrix in the bottom-right corner.

In the second example the best option is to replace the 4 × 4 submatrix containing columns 2 – 5, and the 2 × 2 submatrix consisting of rows 2 – 3 and columns 6 – 7.

In the third example you can select submatrix 3 × 3 in the top-left corner and then submatrix 3 × 3 consisting of rows 2 – 4 and columns 2 – 4.
4
1 10 8 20
***.
***.
***.
...*
9
7
2 1 8 2
.***...
.***..*
.***...
....*..
3
4
10 10 1 10
***.
*..*
*..*
.***
2
5
4 3 4 4
.....
****.
..***
...**
7
6
15 3 18 16
.*.***
...**.
*.....
**..*.
15
5
2 1 2 1
*.***
***.*
.*..*
***..
2
4
2 23 19 1
..**
*...
**.*
.*.*
1
4
18 17 3 15
**..
***.
*..*
****
9
4
13 12 20 12
**.*
....
***.
*.**
12
6
8 2 11 9
.*.***
..**.*
.**.**
*.****
12
6
1 2 2 1
...*.*
.**...
*.*.*.
**...*
2
6
2 2 2 1
*.****
.*....
.*.***
*.***.
2
5
9 19 10 7
.....
*.*.*
.*.**
..**.
14
10
1 1 1 1
.**.*.****
.*.**..***
.*...*..**
*.*.**..*.
3
4
1 1 1 1
****
****
****
****
1
10
433 514 452 478
**********
**********
**********
**********
1434
4
1000 1000 1000 1000
****
****
****
****
1000
4
1 4 9 16
****
**.*
*.**
..**
12
4
1 4 9 15
****
****
****
****
15
33
548 102 31 730
.**..**.**...******.*.**....**.**
**..******...*.*...*.....*....*.*
.**..*...*.**.*.....*..*..**.*..*
.....**.....*..*...***.***..**.**
527
/*input

*/
#include <bits/stdc++.h>
#define up(i,a,b) for(int (i) = (a);(i)<=(b);++(i))
#define down(i,b,a) for(int (i) = (b);i>=(a);--i)
#define bits(x,i) ((x >> i) & 1)
#define mid ((l+r)/2)
#define pr pair<int,int>
using namespace std;
const int N = 1005;
int dp[N][1 << 4][1 << 4][1 << 4];
// i-3th, i-2th, i-1th, ith.  
int c[5];
int a[N];
int n,m;
void minimize(int &x,int y){
	x = min(x, y);
}
void turn_off(int& mask,int i){
	if (bits(mask,i)) mask-=(1 << i);
}
int solve(int cur,int f, int s, int t){
	int& res = dp[cur][f][s][t];
	if (cur >= n + 4) return 0;
	if (res != -1) return res;
	if (!f) return res = solve(cur+1,s, t, a[cur]);
	// take 4 * 4 square/
	res = solve(cur+4, a[cur+1], a[cur+2], a[cur+3]) + c[4];
	for(int sz = 1; sz <= 3;++sz){

		for(int i=0;i<=4-sz;++i){
			int nxt_f = f, nxt_s = s, nxt_t = t;
			for(int j=i;j<=i+sz-1;++j){
				turn_off(nxt_f, j);
				if (sz >= 2) turn_off(nxt_s, j);
				if (sz >= 3) turn_off(nxt_t, j);
			}
			minimize(res, solve(cur, nxt_f, nxt_s, nxt_t) + c[sz]);
		}
	}
	return res;
}
int main(){
	ios_base::sync_with_stdio(0); cin.tie(0);
	cin >> n;
	cin >> c[1] >> c[2] >> c[3] >> c[4];
	up(i,1,4){
		up(j,1,n){
			char c; cin >> c;
			a[j] += (c == '*') << (i - 1);
		}
	}
	memset(dp, -1, sizeof(dp));
	cout << solve(4, a[1], a[2], a[3]);
}
