#include<cstdio>
#include<unordered_map>
#include<vector>
#include<queue>

using namespace std;

int N, ans, cod[109][109];

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

class graph
{
public:
    int N, S, D, t[10009];
    vector < int > v[10009];
    unordered_map < int, int > f[10009], c[10009];

    void add_edge (int x, int y, int cap)
    {
        //printf ("%d -> %d capacitate: %d\n", x, y, cap);
        c[x][y] = cap;
        v[x].push_back (y);
        v[y].push_back (x);
    }

    bool bfs ()
    {
        queue < int > cc;
        for (int i=1; i<=N; i++)
            t[i] = -1;

        cc.push (S);
        t[S] = 0;
        while (!cc.empty())
        {
            int nod = cc.front ();
            cc.pop();
            for (vector < int > :: iterator it = v[nod].begin(); it != v[nod].end(); it ++)
                if (t[*it] == -1 && f[nod][*it] < c[nod][*it])
                {
                    t[*it] = nod;
                    cc.push (*it);
                    if (*it == D)
                        return 1;
                }
        }
        return 0;
    }

    int flux ()
    {
        int F = 0;
        while (bfs ())
        {
            for (vector < int > :: iterator it = v[D].begin(); it != v[D].end(); it ++)
                if (f[*it][D] < c[*it][D] && t[*it] != -1)
                {
                    int mini = 100000000;

                    t[D] = *it;
                    for (int i=D; i != S; i = t[i])
                        if (c[t[i]][i] - f[t[i]][i] < mini)
                            mini = c[t[i]][i] - f[t[i]][i];

                    F += mini;

                    for (int i=D; i != S; i = t[i])
                    {
                        f[t[i]][i] += mini;
                        f[i][t[i]] -= mini;
                    }
                }
        }
        return F;
    }
}graf;

int main()
{
freopen ("pixels.in", "r", stdin);
freopen ("pixels.out", "w", stdout);

scanf ("%d", &N);
graf.S = 1;
graf.D = graf.N = 2;

for (int i=1; i<=N; i++)
    for (int j=1; j<=N; j++)
    {
        cod[i][j] = ++graf.N;
        int x;
        scanf ("%d", &x);
        ans += x;
        graf.add_edge (graf.S, cod[i][j], x);
    }

for (int i=1; i<=N; i++)
    for (int j=1; j<=N; j++)
    {
        int x;
        scanf ("%d", &x);
        ans += x;
        graf.add_edge (cod[i][j], graf.D, x);
    }

for (int i=1; i<=N; i++)
    for (int j=1; j<=N; j++)
        for (int k=0; k<4; k++)
        {
            int x;
            scanf ("%d", &x);
            if (i + dx[k] >= 1 && j + dy[k] >= 1 && i + dx[k] <= N && j + dy[k] <= N)
                graf.add_edge (cod[i][j], cod[i+dx[k]][j+dy[k]], x);
        }

printf ("%d\n", ans - graf.flux ());

return 0;
}


/*#include<cstdio>
#include<vector>
#include<queue>

using namespace std;

int N, ans, cod[109][109];

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

class graph
{
public:
    int N, S, D, t[10009];
    vector < int > v[10009];

    int M, F[50009], C[50009], x[50009], y[50009];////edges

    void add_edge (int left, int right, int cap)
    {
        x[++M] = left, y[M] = right, C[M] = cap, F[M] = 0, v[left].push_back (M);
        x[++M] = right, y[M] = left, C[M] = 0, F[M] = 0, v[right].push_back (M);
    }

    bool bfs ()
    {
        queue < int > cc;
        for (int i=1; i<=N; i++)
            t[i] = -1;

        cc.push (S);
        t[S] = 0;
        while (!cc.empty())
        {
            int nod = cc.front ();
            cc.pop();
            for (vector < int > :: iterator it = v[nod].begin(); it != v[nod].end(); it ++)
            {
                int i = *it;
                if (t[y[i]] == -1 && F[i] < C[i])
                {
                    t[y[i]] = i;
                    cc.push (y[i]);
                    if (y[i] == D)
                        return 1;
                }
            }
        }
        return 0;
    }

    int flux ()
    {
        int F = 0;
        while (bfs ())
        {
            for (vector < int > :: iterator it = v[D].begin(); it != v[D].end(); it ++)
            {
                if (f[*it][D] < c[*it][D])
                {
                    int mini = 1000000;

                    t[D] = *it;
                    for (int i=D; i != S; i = t[i])
                        if (c[t[i]][i] - f[t[i]][i] < mini)
                            mini = c[t[i]][i] - f[t[i]][i];

                    F += mini;

                    for (int i=D; i != S; i = t[i])
                    {
                        f[t[i]][i] += mini;
                        f[i][t[i]] -= mini;
                    }
                }
            }
        }
        return F;
    }
}graf;

void test_class ()
{
    int N, M;
    graf.S = 1, graf.D = graf.N = N;
    scanf ("%d %d", &N, &M);
    while (M)
    {
        M --;
        int x, y, c;
        scanf ("%d %d %d", &x, &y, &c);
        graf.add_edge (x, y, c);
    }
    printf ("%d\n", graf.flux ());
}

int main()
{
freopen ("pixels.in", "r", stdin);
freopen ("pixels.out", "w", stdout);

test_class ();
return 0;

scanf ("%d", &N);
graf.S = 1;
graf.D = graf.N = 2;

for (int i=1; i<=N; i++)
    for (int j=1; j<=N; j++)
    {
        cod[i][j] = ++graf.N;
        int x;
        scanf ("%d", &x);
        ans += x;
        graf.add_edge (graf.S, cod[i][j], x);
    }

for (int i=1; i<=N; i++)
    for (int j=1; j<=N; j++)
    {
        int x;
        scanf ("%d", &x);
        ans += x;
        graf.add_edge (cod[i][j], graf.D, x);
    }

for (int i=1; i<=N; i++)
    for (int j=1; j<=N; j++)
        for (int k=0; k<4; k++)
        {
            int x;
            scanf ("%d", &x);
            if (i + dx[k] >= 1 && j + dy[k] >= 1 && i + dx[k] <= N && j + dy[k] <= N)
                graf.add_edge (cod[i][j], cod[i+dx[k]][j+dy[k]], x);
        }

printf ("%d\n", ans - graf.flux ());

return 0;
}*/