Note the unusual memory limit for the problem.

People working in MDCS (Microsoft Development Center Serbia) like partying. They usually go to night clubs on Friday and Saturday.

There are N people working in MDCS and there are N clubs in the city. Unfortunately, if there is more than one Microsoft employee in night club, level of coolness goes infinitely high and party is over, so club owners will never let more than one Microsoft employee enter their club in the same week (just to be sure).

You are organizing night life for Microsoft employees and you have statistics about how much every employee likes Friday and Saturday parties for all clubs.

You need to match people with clubs maximizing overall sum of their happiness (they are happy as much as they like the club), while half of people should go clubbing on Friday and the other half on Saturday.

Input

The first line contains integer N — number of employees in MDCS.

Then an N × N matrix follows, where element in i-th row and j-th column is an integer number that represents how much i-th person likes j-th club’s Friday party.

Then another N × N matrix follows, where element in i-th row and j-th column is an integer number that represents how much i-th person likes j-th club’s Saturday party.

  * 2 ≤ N ≤ 20
  * N is even 
  * 0 ≤  level of likeness  ≤ 106
  * All values are integers 

Output

Output should contain a single integer — maximum sum of happiness possible.

Examples

Input

4
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
5 8 7 1
6 9 81 3
55 78 1 6
1 1 1 1


Output

167

Note

Here is how we matched people with clubs:

Friday: 1st person with 4th club (4 happiness) and 4th person with 1st club (4 happiness). 

Saturday: 2nd person with 3rd club (81 happiness) and 3rd person with 2nd club (78 happiness).

4+4+81+78 = 167
#include <bits/stdc++.h>
bool used[21];
char P[21], way[21];
int n, m, res, U[21], V[21], minv[21], ar[21][21], fri[21][21], sat[21][21];
int hungarian(int i) {
  int j, i0, i1, j0, j1, cur, delta;
  P[0] = i, j0 = 0;
  for (j = 0; j <= m; j++) minv[j] = (1 << 27), used[j] = false;
  do {
    used[j0] = true;
    i0 = P[j0], j1 = 0, delta = (1 << 27);
    for (j = 1; j <= m; j++) {
      if (!used[j]) {
        cur = ar[i0][j] - U[i0] - V[j];
        if (cur < minv[j]) {
          minv[j] = cur;
          way[j] = j0;
        }
        if (minv[j] < delta) {
          delta = minv[j];
          j1 = j;
        }
      }
    }
    for (j = 0; j <= m; j++) {
      if (used[j]) {
        U[P[j]] += delta;
        V[j] -= delta;
      } else
        minv[j] -= delta;
    }
    j0 = j1;
  } while (P[j0] != 0);
  do {
    j1 = way[j0];
    P[j0] = P[j1];
    j0 = j1;
  } while (j0 != 0);
  return -V[0];
}
void backtrack(int i, int f, int s) {
  if (i == n) return;
  char C[21], D[21];
  int j, x, A[21], B[21];
  if (f) {
    for (j = 0; j <= m; j++)
      A[j] = U[j], B[j] = V[j], C[j] = P[j], D[j] = way[j];
    for (j = 0; j < m; j++) ar[i + 1][j + 1] = -fri[i][j];
    x = -hungarian(i + 1);
    backtrack(i + 1, f - 1, s);
    if (x > res) res = x;
    for (j = 0; j <= m; j++)
      U[j] = A[j], V[j] = B[j], P[j] = C[j], way[j] = D[j];
  }
  if (s) {
    for (j = 0; j <= m; j++)
      A[j] = U[j], B[j] = V[j], C[j] = P[j], D[j] = way[j];
    for (j = 0; j < m; j++) ar[i + 1][j + 1] = -sat[i][j];
    x = -hungarian(i + 1);
    backtrack(i + 1, f, s - 1);
    if (x > res) res = x;
    for (j = 0; j <= m; j++)
      U[j] = A[j], V[j] = B[j], P[j] = C[j], way[j] = D[j];
  }
}
int main() {
  int i, j, k, x;
  while (scanf("%d", &n) != EOF) {
    for (i = 0; i < n; i++) {
      for (j = 0; j < n; j++) {
        scanf("%d", &fri[i][j]);
      }
    }
    for (i = 0; i < n; i++) {
      for (j = 0; j < n; j++) {
        scanf("%d", &sat[i][j]);
      }
    }
    res = 0, m = n;
    memset(way, 0, sizeof(way)), memset(U, 0, sizeof(U)),
        memset(V, 0, sizeof(V)), memset(P, 0, sizeof(P));
    backtrack(0, n >> 1, n >> 1);
    printf("%d\n", res);
  }
  return 0;
}
