#include <bits/stdc++.h>
using namespace std;
using i64 = long long;

signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;
    vector<vector<int>> p(n, vector<int>(m));
    auto w = p;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> p[i][j];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> w[i][j];

    int s = n * m + (n + 1) * m + (m + 1) * n, t = s + 1;
    vector<int> head(t + 1, -1), cost, nxt, cap, to;
    auto add = [&](int x, int y, int f, int c)
    {
        cost.push_back(c);
        cap.push_back(f);
        to.push_back(y);
        nxt.push_back(head[x]);
        head[x] = cost.size() - 1;
        cost.push_back(-c);
        cap.push_back(0);
        to.push_back(x);
        nxt.push_back(head[y]);
        head[y] = cost.size() - 1;
    };
    vector<int> dis(t + 1), g(t + 1);
    const int inf = numeric_limits<int>::max();
    auto bfs = [&]() -> bool
    {
        dis.assign(t + 1, inf);
        dis[s] = 0;
        queue<int> que;
        que.push(s);
        while (!que.empty())
        {
            int cur = que.front();
            g[cur] = head[cur];
            que.pop();
            for (int p = head[cur]; ~p; p = nxt[p])
            {
                if (cap[p] && dis[to[p]] > dis[cur] + cost[p])
                {
                    dis[to[p]] = dis[cur] + cost[p];
                    que.push(to[p]);
                }
            }
        }
        return dis[t] != inf;
    };
    vector<int> vis(t + 1);
    auto dfs = [&](auto &dfs, int cur, int flow) -> int
    {
        if (cur == t)
            return flow;
        int used = 0;
        vis[cur] = 1;
        for (int &p = g[cur]; ~p; p = nxt[p])
        {
            if (!vis[to[p]] && cap[p] && dis[to[p]] == dis[cur] + cost[p])
            {
                int k = dfs(dfs, to[p], min(flow - used, cap[p]));
                used += k;
                cap[p] -= k, cap[p ^ 1] += k;
                if (used == flow)
                    break;
            }
        }
        vis[cur] = 0;
        return used;
    };

    for (int i = n * m; i < s; i++)
        add(i, t, 1, 0);
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            int id = i * m + j;
            add(s, id, w[i][j], 0);
            add(id, n * m + i * m + j, 1, 0);
            add(id, n * m + (i + 1) * m + j, 1, 0);
            add(id, n * m + (n + 1) * m + i * (m + 1) + j, 1, 0);
            add(id, n * m + (n + 1) * m + i * (m + 1) + j + 1, 1, 0);
            if (i + 1 < n)
                add(n * m + (i + 1) * m + j, t, 1, p[i][j] * p[i + 1][j]);
            if (j + 1 < m)
                add(n * m + (n + 1) * m + i * (m + 1) + j + 1, t, 1, p[i][j] * p[i][j + 1]);
        }
    }

    i64 ans = 0;
    while (bfs())
        ans += (i64)dfs(dfs, s, 1e9) * dis[t];
    cout << ans << '\n';
}