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
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

n = int(input())
a = list(map(int, input().split()))
b = [0] * (4 * n)
for i in range(4):
    f = list(input().rstrip())
    for j in range(n):
        b[i + 4 * j] = (46 - f[j]) // 4
for _ in range(4):
    b.append(0)
pow2 = [1]
for _ in range(12):
    pow2.append(2 * pow2[-1])
m = pow2[12]
m0 = m - 1
x = [[pow2[4 * i + j] for i in range(3)] for j in range(4)]
y = []
for k in range(3):
    ak = a[k]
    for i in range(4 - k):
        for j in range(3 - k):
            z = m0
            for u in range(k + 1):
                for v in range(k + 1):
                    z ^= x[i + u][j + v]
            y.append((z, ak))
z = []
c = 0
for i in range(m):
    z0 = []
    for j, k in y:
        if (j ^ m0) & i:
            z0.append((i & j, k))
            c += 1
    z.append(z0)
inf = pow(10, 9) + 1
dp0 = [inf] * m
x = 0
for i in range(12):
    if b[i]:
        x ^= pow2[i]
dp0[x] = 0
for i in range(n - 2):
    for j in range(m0, -1, -1):
        if not dp0[j] ^ inf:
            continue
        dp0j = dp0[j]
        for k, l in z[j]:
            dp0[k] = min(dp0[k], dp0j + l)
    dp = [inf] * m
    dp[0] = min(dp0) + a[3]
    x, k = 0, 8
    for j in range(12 + 4 * i, 16 + 4 * i):
        if b[j]:
            x ^= pow2[k]
        k += 1
    for j in range(0, m, 16):
        dp[j // 16 + x] = dp0[j]
    dp0 = dp
ans = dp[0]
print(ans)