package main

import . "fmt"
import . "sort"
import . "math/rand"

func assert(test bool, msg ...any) {
	if !test {
		if len(msg) > 0 {
			println(Sprint(msg...))
		}
		panic("assert")
	}
}

func main() {
	var n, k int
	Scan(&n, &k)
	n *= 2
	s := make([][]byte, n)
	for i := range s {
		var str string
		Scan(&str)
		s[i] = []byte(str)
	}
	c := make([][]int, n)
	for i := range c {
		c[i] = make([]int, n)
		for j := range c[i] {
			Scan(&c[i][j])
		}
	}
	ss := func(i int) byte { return s[i/n][i%n] }
	cc := func(i int) int { return c[i/n][i%n] }
	
	// not care symmetry
	p := Perm(n*n)
	Slice(p, func(i, j int) bool {
		return cc(p[i]) < cc(p[j])
	})
	var ans int
	for i,j := 0, len(p)-1; i <= j; {
		pi, pj := p[i], p[j]
		if i < j {
			switch {
				case ss(pi) == '.':
					i++
				case ss(pj) == '#':
					ans += cc(pj)
					j--
				default:
					// {pi,pj} = {'#','.'}
					assert(ss(pi) == '#')
					assert(ss(pj) == '.')
					ans += cc(pj)
					i++
					j--
			}
		} else {
			if ss(i) == '#' {
				ans += cc(i)
			}
			break
		}
	}
	
	// care symmetry
	
	sym := func(i int) int { return i-i%n+(n-1-i%n) }
	swap := func(i int) { s[i/n][i%n] = '#'+'.' - s[i/n][i%n] }
	
	Slice(p, func(i, j int) bool {
		return cc(p[i])+cc(sym(p[i])) < cc(p[j])+cc(sym(p[j]))
	})
	
	for i, j := 0, len(p)-1; i < j; {
		pi, pj := p[i], p[j]
		switch {
			case sym(pi) < pi:
				i++
			case sym(pj) < pj:
				j--
			case ss(pi) == '.' && ss(sym(pi)) == '.':
				i++
			case ss(pj) == '#' && ss(sym(pj)) == '#':
				j--
			default:
				assert(pi != pj)
				assert(pi != sym(pi))
				assert(pj != sym(pj))
				// {pi,sym(pi)} = {'.','#'},{'#','.'},{'#','#'}
				// {pj,sym(pj)} = {'.','#'},{'#','.'},{'.','.'}
				assert(ss(pi)=='#'||ss(sym(pi))=='#')
				assert(ss(pj)=='.'||ss(sym(pj))=='.')
				if ss(pi) == '#' {
					if ss(pj) == '.' {
						swap(pi)
						swap(pj)
						assert(ss(pi) == '.')
						assert(ss(pj) == '#')
					} else if ss(sym(pj)) == '.' {
						swap(pi)
						swap(sym(pj))
						assert(ss(pi) == '.')
						assert(ss(sym(pj)) == '#')
					} else {
						panic("bug")
					}
				} else if ss(sym(pi)) == '#' {
					if ss(pj) == '.' {
						swap(sym(pi))
						swap(pj)
						assert(ss(sym(pi)) == '.')
						assert(ss(pj) == '#')
					} else if ss(sym(pj)) == '.' {
						swap(sym(pi))
						swap(sym(pj))
						assert(ss(sym(pi)) == '.')
						assert(ss(sym(pj)) == '#')
					} else {
						panic("bug")
					}
				} else {
					panic("bug")
				}
		}
	}
	tmp := k
	issym := true
	for i := range p {
		if ss(i) != ss(sym(i)) {
			issym = false
			break
		}
		if ss(i) == '#' {
			tmp += cc(i)
		}
	}
	if issym {
		ans = max(ans, tmp)
	}

	Println(ans)
}