//   Bismillahir Rahmanir Rahim      //
                                                 //     After hardship comes ease     //
                                                //         AUTHOR : iamarman         //

// pragmas
// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimization ("unroll-loops")
// #pragma GCC optimization ("strict-overflow")
 
#include<bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

                                                    ////       TEMPLATE       ////

//---------------------------------------------------------------------------------------------------------------------------------|


# define    el '\n'
# define    sp " "
# define    ff first
# define    ss second
# define    ll long long
# define    pb push_back
# define    mp make_pair
# define    yess1 cout<<1<<el 
# define    noo cout<<"NO"<<el
# define    yess cout<<"YES"<<el
# define    siz(x) (int)x.size()
# define    ull unsigned long long    
# define    all(v) v.begin(),v.end()
# define    allr(v) v.rbegin(),v.rend()
# define    torad(x) ((x) * ((2*acos(0))/180.0))
# define    todeg(x) ((x) * (180.0/(2*acos(0))))

constexpr ll modd=998244353;
constexpr ll INF=LLONG_MAX;
constexpr double PI= acos(-1);
constexpr double eps=1e-9;

# define mem(a,b) memset(a,b,sizeof(a))
# define sqr(a) ((a)*(a))
# define lcm(a,b) (a*b)/__gcd(a,b)

# define optimise   { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); }
# define fraction(a) cout.unsetf(ios::floatfield); cout.precision(a); cout.setf(ios::fixed,ios::floatfield);
# define ordered_set tree<ll, null_type,less<ll>, rb_tree_tag,tree_order_statistics_node_update>

// find_by_order() - Returns an iterator to the k-th largest element (counting from zero)
// order_of_key()  - The number of items in a set that are strictly smaller than our item 
// greater instead of less for descending order
// less_equal works as ordered multiset
// we can use pair<int,int> instead of int for pair of orderd set
// for multiset st.lower_bound(x) works as upper bound and st.upper_bound(x) works as lower bound

inline void file() {
#ifndef ONLINE_JUDGE  
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
}
//----------------------------------------------------------------------------------------------------------------------------------|


                                                               // DEBUGGER //


//----------------------------------------------------------------------------------------------------------------------------------|

template < typename F, typename S > ostream& operator << ( ostream& os, const pair< F, S > & p ) { return os << "(" << p.first << ", " << p.second << ")"; }
template < typename T > ostream &operator << ( ostream & os, const vector< T > &v ) { os << "{"; for(auto it = v.begin(); it != v.end(); ++it) { if( it != v.begin() ) os << ", ";  os << *it; }  return os << "}";  }
template < typename T >  ostream &operator << ( ostream & os, const set< T > &v ) { os << "["; for(auto it = v.begin(); it != v.end(); ++it) { if( it != v.begin() ) os << ", "; os << *it;  } return os << "]"; }
template < typename T > ostream &operator << ( ostream & os, const multiset< T > &v ) { os << "["; for(auto it = v.begin(); it != v.end(); ++it) { if( it != v.begin() ) os << ", "; os << *it; } return os << "]"; }
template < typename F, typename S > ostream &operator << ( ostream & os, const map< F, S > &v ) { os << "["; for(auto it = v.begin(); it != v.end(); ++it) { if( it != v.begin() ) os << ", "; os << it -> first << " = " << it -> second ; } return os << "]";  }
#define dbg(args...) do {cerr << #args << " : "; iamarman(args); } while(0)
void iamarman () { cerr << endl; }
template <typename T> void iamarman( T a[], int n ) {   for(int i = 0; i < n; ++i) cerr << a[i] << ' '; cerr << endl;  }
template <typename T, typename ... hello>  void iamarman( T arg, const hello &... rest) {   cerr << arg << ' ';  iamarman(rest...);  }

//--------------------------------------------------------------------------------------------------------------------------------------|



                                                           /////    FUNCTIONS     /////



// ll bigmod(ll base,ll power){ ll res=1; ll p=base%mod; while(power>0) { if(power%2==1) {  res=((res%mod)*(p%mod))%mod; }  power/=2; p=((p%mod)*(p%mod))%mod; } return res; }

// ll inversemod(ll base) { return bigmod(base,mod-2); }

// ll poww(ull a,ull b) { ull ans=1; if(!b) return 1; while(b>1) {  if(b&1) { ans=ans*a%mod; } a=a*a%mod; b/=2; }return a*ans%mod; }

// ll gcd(ll a,ll b) { ll rem; while(b%a!=0)  {  rem=b%a;  b=a;  a=rem; } return a; }

// ll sqrtt(ll a){ long long x = sqrt(a) + 2; while (x * x > a) x--; return x;}

// ll sqrt(ll n) {ll low=0,high=1e10; while(high-low>1){ ll mid=low+(high-low)/2; if(mid*mid<=n) low=mid; else high=mid; }return low; }

// long double sqrtd(long double n){ long double low=0,high=n,mid; for(int i=0;i<100;i++) { mid=(low+high)/2; if(mid*mid<=n) low=mid; else high=mid;} return low;}

mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

inline ll getrandom(ll a,ll b) { return uniform_int_distribution<ll>(a,b)(rng); }

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

// up = { -1,0 } , down = { 1,0 } , right = { 0,1 } , left = { 0,-1 }
// up-right = { -1,1 } , up-left = { -1,-1 } , down-right = { 1,1 } , down-left = { 1,-1 }




                                                   ///  ____________CODE STARTS FROM HERE____________    ///

constexpr ll mod=1000012253;
template<typename T>
class Hashing {
private:
    int n;
    string s;
    T base;
    vector<T> prefix_hash;
    vector<T> power;
    vector<T> inv;

    vector<int> bases = {37,61,79,83,97,53,61,
                         107,127,137,163,191 ,
                         199,211,229,239,263 ,
                         271,281,293};

    T rng() {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<T> dis(0, std::numeric_limits<T>::max());
        return dis(gen);
    }

    T mul(T a, T b, T mod) {
        return ((1LL * a % mod) * (b % mod)) % mod;
    }

    T add(T a, T b, T mod) {
        return (1LL * a + b) % mod;
    }

    T sub(T a, T b, T mod) {
        return ((a % mod) - (b % mod) + 2LL * mod) % mod;
    }

    T bigmod(T base, T power, T mod) {
        T res = 1;
        while (power > 0) {
            if (power & 1) {
                res = mul(res, base, mod);
            }
            base = mul(base, base, mod);
            power >>= 1;
        }
        return res;
    }

public:
    Hashing(const std::string& str) : s(str) {
        n = s.size();
        base = 79;
        prefix_hash.resize(n + 1, 0);
        power.resize(n + 1, 0);
        inv.resize(n + 1, 0);
        precom();
    }

    void precom() {
        power[0] = 1;
        for (int i = 1; i <= n; i++) {
            power[i] = (1LL * power[i - 1] * base) % mod;
        }

        T inv_base = bigmod(base, mod - 2, mod);
        inv[0] = 1;
        for (int i = 1; i <= n; i++) {
            inv[i] = mul(inv[i - 1], inv_base, mod);
        }

        prefix_hash[0] = 0;
        for (int i = 1; i <= n; i++) {
            int ch = s[i - 1] - 'a' + 1;
            prefix_hash[i] = (1LL * prefix_hash[i - 1] + mul(ch, power[i - 1], mod)) % mod;
        }
    }

    T get_hash(int l, int r) {
        T val = sub(prefix_hash[r], prefix_hash[l - 1], mod);
        val = mul(val, inv[l], mod);
        return val;
    }
    T combine(T hash1, T hash2, int len1) {
        return add(mul(hash1, power[len1], mod), hash2, mod);
    }
};


void solve()
{  
    int n,m;
    cin>>n>>m;

    vector<int> x[n*m+1],y[n*m+1];
    map<int,int> mp;
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            int col;
            cin>>col;
            if(mp.find(col)==mp.end())
            {
                cnt++;
                mp[col]=cnt;
            }
            x[mp[col]].pb(i);
            y[mp[col]].pb(j);
            
        }
    }

    ll ans=0;

    for(int i=1;i<=n*m;i++)
    {
        if(siz(x[i])!=0)
        {
            sort(all(x[i]));
            ll sum=accumulate(all(x[i]),0);
            ll sum1=0;
            for(int j=0;j<siz(x[i]);j++)
            {
                ll cur=abs(sum1-x[i][j]*j);
                sum1+=x[i][j];
                sum-=x[i][j];
                cur+=abs(sum-x[i][j]*(siz(x[i])-j-1));
                ans+=cur;
            }
        }
        if(siz(y[i])!=0)
        {
            sort(all(y[i]));
            ll sum=accumulate(all(y[i]),0);
            ll sum1=0;
            for(int j=0;j<siz(y[i]);j++)
            {
                ll cur=abs(sum1-y[i][j]*j);
                sum1+=y[i][j];
                sum-=y[i][j];
                cur+=abs(sum-y[i][j]*(siz(y[i])-j-1));
                ans+=cur;
            }
        }
    }

    cout<<ans<<el;


}


int main()
{ 
    optimise;
    file();

    clock_t start= clock();
    int t=1;
  //  cin>>t;
    for(int i=1;i<=t;i++)
    {
       // cout<<"Case "<<i<<": ";
        solve();
       
    }
    cerr << "Run Time : " <<((double)(clock() - start) / CLOCKS_PER_SEC)<<el;
  
}