// Original C++ solution (slower):
#include<cstdio>

#include<vector>

#include<queue>

#include<map>

#include<set>

#include<unordered_map>

#include<stack>

#include<string>

#include<algorithm>

#include<functional>

#include<cstring>

#include<complex>

#include<bitset>

#include<iostream>

#include<cassert>

using namespace std;



typedef long long ll;

typedef pair<ll, ll> P;

typedef pair<ll, P> Q;

typedef complex<double> C;

#define cx real()

#define cy imag()

const ll INF = 1LL << 60;

const double DINF = 1e30;

const ll mod = 1000000007;

const ll dx[4] = {1, 0, -1, 0};

const ll dy[4] = {0, -1, 0, 1};

const C I = C(0, 1);

const double EPS = 1e-10;

const ll NCK_MAX = 510000;



ll gcd(ll a, ll b) {

  if (b == 0) return a;

  return gcd(b, a % b);

}



ll extgcd(ll a, ll b, ll& x, ll& y) {

  if (b == 0) {

    x = 1, y = 0; return a;

  }

  ll q = a/b, g = extgcd(b, a - q*b, x, y);

  ll z = x - q * y;

  x = y;

  y = z;

  return g;

}



ll invmod (ll a, ll m) { // a^-1 mod m

  ll x, y;

  extgcd(a, m, x, y);

  x %= m;

  if (x < 0) x += m;

  return x;

}



ll *fac, *finv, *inv;



void nCk_init(ll mod) {

  fac = new ll[NCK_MAX];

  finv = new ll[NCK_MAX];

  inv = new ll[NCK_MAX];

  fac[0] = fac[1] = 1;

  finv[0] = finv[1] = 1;

  inv[1] = 1;

  for (ll i = 2; i < NCK_MAX; i++) {

    fac[i] = fac[i-1] * i % mod;

    inv[i] = mod - inv[mod%i] * (mod / i) % mod;

    finv[i] = finv[i-1] * inv[i] % mod;

  }

}



ll nCk(ll n, ll k, ll mod) {

  if (fac == NULL) nCk_init(mod);

  if (n < k) return 0;

  if (n < 0 || k < 0) return 0;

  return fac[n] * (finv[k] * finv[n-k] % mod) % mod;

}



template <typename T>

class Zip {

  vector<T> d;

  bool flag;

  void init() {

    sort(d.begin(), d.end());

    d.erase(unique(d.begin(), d.end()), d.end());

    flag = false;

  }

public:

  Zip() {

    flag = false;

  }

  void add(T x) {

    d.push_back(x);

    flag = true;

  }

  ll getNum(T x) {

    if (flag) init();

    return lower_bound(d.begin(), d.end(), x) - d.begin();

  }

  ll size() {

    if (flag) init();

    return (ll)d.size();

  }

};



class UnionFind {

  vector<ll> par, rank; // par > 0: number, par < 0: -par

public:

  UnionFind(ll n) : par(n, 1), rank(n, 0) {}

  ll getSize(ll x) {

    return par[find(x)];

  }

  ll find(ll x) {

    if (par[x] > 0) return x;

    return -(par[x] = -find(-par[x]));

  }

  void merge(ll x, ll y) {

    x = find(x);

    y = find(y);

    if (x == y) return;

    if (rank[x] < rank[y]) {

      par[y] += par[x];

      par[x] = -y;

    } else {

      par[x] += par[y];

      par[y] = -x;

      if (rank[x] == rank[y]) rank[x]++;

    }

  }

  bool isSame(ll x, ll y) {

    return find(x) == find(y);

  }

};





template <typename T>

class SegmentTree {

  ll n;

  vector<T> node;

  function<T(T, T)> fun, fun2;

  bool customChange;

  T outValue, initValue;

public:

  void init(ll num, function<T(T, T)> resultFunction, T init, T out, function<T(T, T)> changeFunction = NULL) {

    // changeFunction: (input, beforevalue) => newvalue

    fun = resultFunction;

    fun2 = changeFunction;

    customChange = changeFunction != NULL;

    n = 1;

    while (n < num) n *= 2;

    node.resize(2 * n - 1);

    fill(node.begin(), node.end(), init);

    outValue = out;

    initValue = init;

  }

  void valueChange(ll num, T value) {

    num += n-1;

    if (customChange) node[num] = fun2(value, node[num]);

    else node[num] = value;

    while (num > 0) num = (num - 1) / 2, node[num] = fun(node[num * 2 + 1], node[num * 2 + 2]);

  }

  T rangeQuery(ll a, ll b, ll l = 0, ll r = -1, ll k = 0) { // [a, b)

    if (r == -1) r = n;

    if (a <= l && r <= b) return node[k];

    if (b <= l || r <= a) return outValue;

    ll mid = (l + r) / 2;

    return fun(rangeQuery(a, b, l, mid, 2*k+1), rangeQuery(a, b, mid, r, 2*k+2));

  }

};



template <typename T>

class Graph {

  struct edge { ll to; T cost; };

  struct edge_data { ll from, to; T cost; };



  ll v;

  vector<vector<edge>> e, re;

  vector<edge_data> ed;

  vector<bool> used;

  vector<ll> vs, cmp;

  bool isDirected, isMinasEdge;

public:

  Graph(ll _v, bool _isDirected = true, ll range_add = 0) {

    // range_add 0:no / 1:in / 2:out / 3:in+out

    //_v++;

    v = _v, isDirected = _isDirected; isMinasEdge = false;

    e.resize(v), re.resize(v);

  }

  void add_edge(ll s, ll t, T cost = 1) {

    e[s].push_back((edge){t, cost});

    if (!isDirected) e[t].push_back((edge){s, cost});

    else re[t].push_back((edge){s, cost});

    ed.push_back((edge_data){s, t, cost});

    if (cost < 0) isMinasEdge = true;

  }

  vector<T> dijkstra(ll s) {

    vector<T> d(v, INF);

    d[s] = 0;

    auto edge_cmp = [](const edge& a, const edge& b) { return a.cost > b.cost; };

    priority_queue<edge, vector<edge>, decltype(edge_cmp)> pq(edge_cmp);

    pq.push((edge){s, 0});

    while (!pq.empty()) {

      edge temp = pq.top(); pq.pop();

      if (d[temp.to] < temp.cost) continue;

      for (const edge& next : e[temp.to]) {

        T cost = temp.cost + next.cost;

        if (d[next.to] > cost) {

          d[next.to] = cost;

          pq.push((edge){next.to, cost});

        }

      }

    }

    return d;

  }

  vector<T> bellmanford(ll s) {

    vector<T> d(v, INF);

    d[s] = 0;

    for (ll i = 0; i < v; i++) {

      for (const edge_data& temp : ed) {

        if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost) d[temp.to] = d[temp.from] + temp.cost;

        if (!isDirected && d[temp.to] != INF && d[temp.from] > d[temp.to] + temp.cost) d[temp.from] = d[temp.to] + temp.cost;

      }

    }

    for (ll i = 0; i < v; i++) {

      for (const edge_data& temp : ed) {

        if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost) d[temp.to] = -INF;

        if (!isDirected && d[temp.to] != INF && d[temp.from] > d[temp.to] + temp.cost) d[temp.from] = -INF;

      }

    }

    return d;

  }

  vector<T> shortest_path(ll s) {

    if (isMinasEdge) return bellmanford(s);

    else return dijkstra(s);

  }

  T kruskal() {

    // if (isDirected)

    UnionFind uf(v);

    auto edge_data_cmp = [](const edge_data& a, const edge_data& b) { return a.cost < b.cost; };

    sort(ed.begin(), ed.end(), edge_data_cmp);

    T ans = 0;

    for (const edge_data& temp : ed) {

      if (uf.isSame(temp.from, temp.to)) continue;

      uf.merge(temp.from, temp.to);

      ans += temp.cost;

    }

    return ans;

  }

  void scc_dfs(ll s) {

    used[s] = true;

    for (const edge& i : e[s]) if (!used[i.to]) scc_dfs(i.to);

    vs.push_back(s);

  }

  void scc_rdfs(ll s, ll k) {

    used[s] = true;

    cmp[s] = k;

    for (const edge& i : re[s]) if (!used[i.to]) scc_rdfs(i.to, k);

  }

  vector<ll> scc() {

    used.resize(v);

    fill(used.begin(), used.end(), false);

    cmp.resize(v);

    vs.clear();

    for (ll i = 0; i < v; i++) if (!used[i]) scc_dfs(i);

    used.resize(v);

    fill(used.begin(), used.end(), false);

    ll k = 0;

    for (ll i = vs.size() - 1; i >= 0; i--) if (!used[vs[i]]) scc_rdfs(vs[i], k++);

    return cmp;

  }

};



ll h, w, a[80][80], b[80][80], mid = 14000;

bitset<28000> dp[80][80];



int main() {

  scanf("%lld%lld", &h, &w);

  for (ll i = 0; i < h; i++) for (ll j = 0; j < w; j++) scanf("%lld", &a[i][j]);

  for (ll i = 0; i < h; i++) for (ll j = 0; j < w; j++) scanf("%lld", &b[i][j]);

  dp[0][0][mid+a[0][0]-b[0][0]] = true;

  dp[0][0][mid-a[0][0]+b[0][0]] = true;

  for (ll i = 0; i < h; i++) for (ll j = 0; j < w; j++) if (i + j > 0) {

    bitset<28000> temp;

    if (i == 0) temp = dp[i][j-1];

    else if (j == 0) temp = dp[i-1][j];

    else temp = dp[i-1][j] | dp[i][j-1];

    ll x = abs(a[i][j]-b[i][j]);

    dp[i][j] = (temp >> x) | (temp << x);

  }

  for (ll i = 0;; i++) if (dp[h-1][w-1][mid-i] || dp[h-1][w-1][mid+i]) {

    printf("%lld\n", i);

    return 0;

  }

}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<bitset>

#include<cmath>

using namespace std;



int h, w, a[80][80], b[80][80], mid = 6480;

bitset<12960> dp[2][80], temp;

 

int main() {

  scanf("%d%d", &h, &w);

  for (int i = 0; i < h; i++) for (int j = 0; j < w; j++) scanf("%d", &a[i][j]);

  for (int i = 0; i < h; i++) for (int j = 0; j < w; j++) scanf("%d", &b[i][j]);

  dp[0][0][mid+a[0][0]-b[0][0]] = true;

  dp[0][0][mid-a[0][0]+b[0][0]] = true;

  for (int i = 0; i < h; i++) for (int j = 0; j < w; j++) if (i + j > 0) {

    if (i == 0) temp = dp[i&1][j-1];

    else if (j == 0) temp = dp[!(i&1)][j];

    else temp = dp[!(i&1)][j] | dp[i&1][j-1];

    int x = abs(a[i][j]-b[i][j]);

    dp[i&1][j] = (temp >> x) | (temp << x);

  }

  for (int i = 0;; i++) if (dp[!(h&1)][w-1][mid-i] || dp[!(h&1)][w-1][mid+i]) {

    printf("%d\n", i);

    return 0;

  }

}


// Fastest known solution for this problem: