#include <fstream>
#include <vector>
#include <queue>
#include <cstring>

using namespace std;

ifstream fin ("pixels.in"); ofstream fout ("pixels.out");

const int nmax = 100 * 100 + 5;
const int mmax = 6 * nmax;

struct muchie {
    int x, cap, indop;

    muchie() {}
    muchie (int _x, int _cap, int _indop) {
        x = _x, cap = _cap, indop = _indop;
    }
} v[mmax + 1];

int n, nrm, S, D;
int total;
int tata[nmax + 1], intra[nmax + 1];

vector< int > g[nmax + 1];
queue< int > q;

void trage_muchie (int x, int y, int cap) {
    ++ nrm;
    v[ nrm ] = muchie(y, cap, nrm + 1);
    g[ x ].push_back( nrm );

    ++ nrm;
    v[ nrm ] = muchie(x, 0, nrm - 1);
    g[ y ].push_back( nrm );
}

void citire() {
    fin >> n;

    S = n * n + 1;
    D = S + 1;
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= n; ++ j) {
            int x;
            fin >> x;
            total += x;

            trage_muchie(S, (i - 1) * n + j, x);
        }
    }

    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= n; ++ j) {
            int x;
            fin >> x;
            total += x;

            trage_muchie((i - 1) * n + j, D, x);
        }
    }

    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= n; ++ j) {
            int a, b, x, y;
            fin >> a >> b >> x >> y;

            if (i + 1 <= n) {
                trage_muchie((i - 1) * n + j, (i + 1 - 1) * n + j, x);
            }
            if (1 <= j - 1) {
                trage_muchie((i - 1) * n + j, (i - 1) * n + (j - 1), y);
            }
        }
    }
}

bool bfs () {
    memset(tata, -1, sizeof(tata));
    tata[ S ] = 0;
    q.push( S );

    while (!q.empty()) {
        int x = q.front();
        q.pop();

        for (auto i : g[ x ]) {
            if (tata[ v[ i ].x ] == -1 && v[ i ].cap > 0) {
                tata[ v[ i ].x ] = x;
                intra[ v[ i ].x ] = i;
                q.push( v[ i ].x );
            }
        }
    }

    return tata[ D ] != -1;
}

int main() {
    citire();

    int ans = 0;
    while (bfs()) {
        for (auto i : g[ D ]) {
            if (tata[ v[ i ].x ] != -1 && v[ v[ i ].indop ].cap > 0) {
                int flmin = v[ v[ i ].indop ].cap;

                for (int x = v[ i ].x; x != S; x = tata[ x ]) {
                    flmin = min(flmin, v[ intra[ x ] ].cap);
                }

                ans += flmin;

                v[ v[ i ].indop ].cap -= flmin;
                v[ i ].cap += flmin;

                for (int x = v[ i ].x; x != S; x = tata[ x ]) {
                    v[ intra[ x ] ].cap -= flmin;
                    v[ v[ intra[ x ] ].indop ].cap += flmin;
                }
            }
        }
    }

    fout << total - ans << "\n";

    fin.close();
    fout.close();
    return 0;
}