#include <bits/stdc++.h>

using namespace std;


namespace sk {
    // modint: https://www.cnblogs.com/hzy1/p/16344746.html
    // Edited by Starrykiller.
    using i64=int64_t;
    using u64=unsigned i64;
    using i32=int32_t;
    i32 inverse(i32 a, i32 m) { i32 r=1;
        while (a>1) { i32 t=m/a; r=i64(r)*(m-t)%m; a=m-t*a; }
        return r;
    }
    template<i32 mod>
    struct static_modint { 
        i32 x;
        static_modint(i64 x) : x(normal(x%mod)) {}
        static_modint(i32 x, nullptr_t) : x(x) {}
        static_modint(): x(0) {}
        inline constexpr i32 normal(i32 x) { 
            if (x>=mod) x-=mod;
            return x+((x>>31)&mod); 
        }
        inline constexpr i32 val() const { return x; }
        inline constexpr explicit operator bool() const { return x; }
        inline constexpr static_modint inv() const { assert(x!=0); return static_modint(inverse(x,mod),nullptr); }
        inline constexpr static_modint pow(i64 x) const { assert(x>=0); static_modint a=*this, res=1;
            while (x) { if (x&1) res*=a; a*=a; x>>=1; } return res; }
        inline constexpr static_modint operator-() const { return static_modint(mod-x); }
        inline constexpr static_modint& operator+=(const static_modint &rhs) { x=normal(x+rhs.x); return *this; }
        inline constexpr static_modint& operator-=(const static_modint &rhs) { x=normal(x-rhs.x); return *this; }
        inline constexpr static_modint& operator++() { return (*this)+=1; }
        inline constexpr static_modint& operator--() { return (*this)-=1; }
        inline constexpr static_modint& operator*=(const static_modint &rhs) { x=i64(x)*rhs.x%mod; return *this; }
        inline constexpr static_modint& operator/=(const static_modint &rhs) { return *this *= rhs.inv(); }
        friend static_modint operator+(const static_modint &lhs, const static_modint &rhs) { auto res=lhs; res+=rhs; return res; }
        friend static_modint operator-(const static_modint &lhs, const static_modint &rhs) { auto res=lhs; res-=rhs; return res; }
        friend static_modint operator*(const static_modint &lhs, const static_modint &rhs) { auto res=lhs; res*=rhs; return res; }
        friend static_modint operator/(const static_modint &lhs, const static_modint &rhs) { auto res=lhs; res/=rhs; return res; }
        friend static_modint operator++(static_modint &x, int) { auto tmp=x; x+=1; return tmp; }
        friend static_modint operator--(static_modint &x, int) { auto tmp=x; x-=1; return tmp; }
        friend std::istream& operator>>(std::istream &is, static_modint &a) { i64 v; is >> v; a=static_modint(v%mod); return is; }
        friend std::ostream& operator<<(std::ostream &os, const static_modint &a) { os << a.val(); return os; }
        bool operator==(const static_modint& rhs) const { return x==rhs.x; }
        bool operator!=(const static_modint& rhs) const { return x!=rhs.x; }
    };
    using modint998244353=static_modint<998244353>;
    using modint1000000007=static_modint<1000000007>;
};

constexpr int MAXN=5e5+10; using ll=sk::modint1000000007;
int n, m, h;
int id(int x, int y) { return (x-1)*m+y; }
struct E { int u, v, w; }; vector<E> e;
int fa[MAXN], siz[MAXN], val[MAXN]; ll f[MAXN];
int get(int x) { return fa[x]==x?x:fa[x]=get(fa[x]); }

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);
    cin>>n>>m>>h;
    for (int i=1; i<=n; ++i) for (int j=1,w; j<m; ++j)  
        cin>>w, e.push_back({id(i,j),id(i,j+1),w});
    for (int i=1; i<n; ++i) for (int j=1,w; j<=m; ++j)  
        cin>>w, e.push_back({id(i,j),id(i+1,j),w});
    sort(e.begin(),e.end(),[](const E& a, const E& b) { return a.w<b.w; });
    for (int i=1; i<=n*m; ++i) siz[fa[i]=i]=1, val[i]=-1; int cur=0;
    for (auto [u,v,w]: e) {
        u=get(u), v=get(v);
        if (u==v) continue;
        f[v]=(f[u]+w-val[u])*(f[v]+w-val[v]);
        fa[u]=v; siz[v]+=siz[u]; val[v]=w;
        cur=w;
    }
    ll ans=f[get(1)];
    ans+=h-cur;
    cout<<ans<<'\n';


}