For problem statement at 0-999/900-999/900-909/903/problemF.txt this is a correct solution, but verifier at 0-999/900-999/900-909/903/verifierF.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const INF = 1 << 30

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		x := 0
		for _, b := range scanner.Bytes() {
			x = x*10 + int(b-'0')
		}
		return x
	}

	n := readInt()
	a := make([]int, 4)
	for i := 0; i < 4; i++ {
		a[i] = readInt()
	}

	grid := make([]string, 4)
	for i := 0; i < 4; i++ {
		scanner.Scan()
		grid[i] = scanner.Text()
	}

	ast := make([]int, n)
	for j := 0; j < n; j++ {
		mask := 0
		for i := 0; i < 4; i++ {
			if grid[i][j] == '*' {
				mask |= 1 << i
			}
		}
		ast[j] = mask
	}

	type Square struct {
		cover int
		m1    int
		m2    int
		m3    int
		cost  int
	}
	squares := make([]Square, 0, 10)

	for r := 0; r < 4; r++ {
		squares = append(squares, Square{1 << r, 0, 0, 0, a[0]})
	}
	for r := 0; r < 3; r++ {
		mask := (1 << r) | (1 << (r + 1))
		squares = append(squares, Square{mask, mask, 0, 0, a[1]})
	}
	for r := 0; r < 2; r++ {
		mask := (1 << r) | (1 << (r + 1)) | (1 << (r + 2))
		squares = append(squares, Square{mask, mask, mask, 0, a[2]})
	}
	squares = append(squares, Square{0b1111, 0b1111, 0b1111, 0b1111, a[3]})

	m1List := []int{0, 3, 6, 12, 7, 14, 15}
	m2List := []int{0, 7, 14, 15}
	m3List := []int{0, 15}

	m1Idx := make([]int, 16)
	m2Idx := make([]int, 16)
	m3Idx := make([]int, 16)
	for i := range m1Idx {
		m1Idx[i] = -1
	}
	for i := range m2Idx {
		m2Idx[i] = -1
	}
	for i := range m3Idx {
		m3Idx[i] = -1
	}
	for i, v := range m1List {
		m1Idx[v] = i
	}
	for i, v := range m2List {
		m2Idx[v] = i
	}
	for i, v := range m3List {
		m3Idx[v] = i
	}

	trans := make([][]int, 16)
	for i := range trans {
		trans[i] = make([]int, 64)
		for j := range trans[i] {
			trans[i][j] = INF
		}
	}

	for s := 0; s < (1 << 10); s++ {
		cover := 0
		m1, m2, m3 := 0, 0, 0
		cost := 0
		for i := 0; i < 10; i++ {
			if s&(1<<i) != 0 {
				sq := squares[i]
				cover |= sq.cover
				m1 |= sq.m1
				m2 |= sq.m2
				m3 |= sq.m3
				cost += sq.cost
			}
		}
		i1 := m1Idx[m1]
		i2 := m2Idx[m2]
		i3 := m3Idx[m3]
		if i1 < 0 || i2 < 0 || i3 < 0 {
			continue
		}
		id := (i1*4 + i2) * 2 + i3

		sub := cover
		for {
			need := sub
			if cost < trans[need][id] {
				trans[need][id] = cost
			}
			if sub == 0 {
				break
			}
			sub = (sub - 1) & cover
		}
	}

	idToM1 := make([]int, 64)
	idToM2 := make([]int, 64)
	idToM3 := make([]int, 64)
	for i1, m1 := range m1List {
		for i2, m2 := range m2List {
			for i3, m3 := range m3List {
				id := (i1*4 + i2) * 2 + i3
				idToM1[id] = m1
				idToM2[id] = m2
				idToM3[id] = m3
			}
		}
	}

	dp := [16][16][16]int{}
	newDp := [16][16][16]int{}
	for i := 0; i < 16; i++ {
		for j := 0; j < 16; j++ {
			for k := 0; k < 16; k++ {
				dp[i][j][k] = INF
			}
		}
	}
	dp[0][0][0] = 0

	for col := 0; col < n; col++ {
		A := ast[col]
		for i := 0; i < 16; i++ {
			for j := 0; j < 16; j++ {
				for k := 0; k < 16; k++ {
					newDp[i][j][k] = INF
				}
			}
		}

		for c0 := 0; c0 < 16; c0++ {
			for c1 := 0; c1 < 16; c1++ {
				for c2 := 0; c2 < 16; c2++ {
					cur := dp[c0][c1][c2]
					if cur == INF {
						continue
					}
					need := A & (^c0)
					for id := 0; id < 64; id++ {
						add := trans[need][id]
						if add == INF {
							continue
						}
						nc0 := c1 | idToM1[id]
						nc1 := c2 | idToM2[id]
						nc2 := idToM3[id]
						val := cur + add
						if val < newDp[nc0][nc1][nc2] {
							newDp[nc0][nc1][nc2] = val
						}
					}
				}
			}
		}
		dp = newDp
	}

	ans := INF
	for i := 0; i < 16; i++ {
		for j := 0; j < 16; j++ {
			for k := 0; k < 16; k++ {
				if dp[i][j][k] < ans {
					ans = dp[i][j][k]
				}
			}
		}
	}
	fmt.Println(ans)
}
```