// #pragma GCC optimize("O3,unroll-loops,Ofast")
// #pragma GCC target("avx2")
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define int long long
#define endl '\n'

using namespace std;
using pii = pair<int, int>;
using tup = tuple<int, int, int>;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T> using ordered_set = tree<T, null_type,
                         less<T>, rb_tree_tag, tree_order_statistics_node_update>;

const int inf = 1e18;
const int mod = 1000000007;
const double eps = 1e-9;
const int N = 200005;

void preprocess() {}

int n, k;
vector<tup> edges;

int p[N][5], sz[N], par[N];

int dist(int pi, int pj) {
    int ret = 0;
    for(int i=0; i<k; i++) ret += abs(p[pi][i] - p[pj][i]);
    return ret;
}

int find(int x) {
    return par[x] = (par[x] == x ? x : find(par[x]));
}

void join(int u, int v) {
    u = find(u);
    v = find(v);
    if(u == v) return;
    sz[u] += sz[v];
    par[v] = u;
}

int kruskal() {
    sort(edges.rbegin(), edges.rend());
    for(int i=1; i<=n; i++) par[i] = i, sz[i] = 1;

    int ans = 0;
    for(auto [d, u, v] : edges) {
        if(find(u) == find(v)) continue;
        ans += d;
        join(u, v);
    } 
    return ans;
}

int val[1<<5];
int who[1<<5];

void solve(int tc) {
    cin >> n >> k;
    for(int i=0; i<(1 << k); i++) val[i] = -inf;

    for(int i=1; i<=n; i++) {
        for(int j=0; j<k; j++) cin >> p[i][j];

        for(int mask=0; mask<(1<<k); mask++) {
            int sum = 0;
            for(int j=0; j<k; j++) {
                if(mask & (1 << j)) sum += p[i][j];
                else sum -= p[i][j];
            }
            if(val[mask] < sum) {
                val[mask] = sum;
                who[mask] = i;
            }
        }
    }

    for(int i=1; i<=n; i++) {
        for(int mask=0; mask<(1<<k); mask++) {
            int inv = ((1 << k) - 1) ^ mask;
            if(!who[inv]) continue;
            int sum = 0;
            for(int j=0; j<k; j++) {
                if(mask & (1 << j)) sum += p[i][j];
                else sum -= p[i][j];
            }

            edges.push_back({sum + val[inv], i, who[inv]});
        }
    }

    cout << kruskal() << endl;
}
     
int32_t main() {
    cin.tie(NULL)->sync_with_stdio(false);
    cout.precision(10);

    preprocess(); 

    int T = 1;
    // cin >> T;

    for (int i = 1; i <= T; i++) {
        solve(i);
    }

    return 0;
}