```go
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var N int
	fmt.Fscan(reader, &N)

	F := make([][]int32, N)
	for i := 0; i < N; i++ {
		F[i] = make([]int32, N)
		for j := 0; j < N; j++ {
			fmt.Fscan(reader, &F[i][j])
		}
	}

	S := make([][]int32, N)
	for i := 0; i < N; i++ {
		S[i] = make([]int32, N)
		for j := 0; j < N; j++ {
			fmt.Fscan(reader, &S[i][j])
		}
	}

	C := make([][]int, N+1)
	for i := 0; i <= N; i++ {
		C[i] = make([]int, N+1)
		C[i][0] = 1
		for j := 1; j <= i; j++ {
			C[i][j] = C[i-1][j-1] + C[i-1][j]
		}
	}

	getIndex := func(mask, k int) int {
		idx := 0
		for j := N - 1; j >= 0 && k > 0; j-- {
			if (mask & (1 << j)) != 0 {
				idx += C[j][k]
				k--
			}
		}
		return idx
	}

	maxComb := C[N][N/2]
	dp := make([][11]int32, maxComb)
	nextDp := make([][11]int32, maxComb)

	for i := 0; i < maxComb; i++ {
		for f := 0; f <= N/2; f++ {
			dp[i][f] = -1
		}
	}
	dp[0][0] = 0

	for i := 0; i < N; i++ {
		numNextMasks := C[N][i+1]
		for j := 0; j < numNextMasks; j++ {
			for f := 0; f <= N/2; f++ {
				nextDp[j][f] = -1
			}
		}

		var mask int
		if i == 0 {
			mask = 0
		} else {
			mask = (1 << i) - 1
		}

		fMin := 0
		if i-N/2 > 0 {
			fMin = i - N/2
		}
		fMax := i
		if N/2 < fMax {
			fMax = N/2
		}

		for mask < (1 << N) {
			idx := getIndex(mask, i)

			for c := 0; c < N; c++ {
				if (mask & (1 << c)) == 0 {
					newMask := mask | (1 << c)
					newIdx := getIndex(newMask, i+1)

					for f := fMin; f <= fMax; f++ {
						val := dp[idx][f]
						if val == -1 {
							continue
						}

						if (i + 1 - f) <= N/2 {
							cand := val + S[i][c]
							if cand > nextDp[newIdx][f] {
								nextDp[newIdx][f] = cand
							}
						}

						if f+1 <= N/2 {
							cand := val + F[i][c]
							if cand > nextDp[newIdx][f+1] {
								nextDp[newIdx][f+1] = cand
							}
						}
					}
				}
			}

			if i == 0 {
				break
			}
			c_bit := mask & -mask
			r := mask + c_bit
			mask = (((r ^ mask) >> 2) / c_bit) | r
		}

		dp, nextDp = nextDp, dp
	}

	fmt.Println(dp[0][N/2])
}
```