#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <cstring>
#include <queue>
#include <set>
#include <cmath>
#include <random>
#include <tuple>
#include <numeric>
#include <map>
#include <iomanip>
#include <cassert>
#include <bitset>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int mod = 1e9 + 7;

template <typename T, typename = void>
struct has_val_function : std::false_type {};

template <typename T>
struct has_val_function<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<T>().val())>> : std::true_type { };

template<typename t>
typename std::enable_if_t<has_val_function<t>::value, std::ostream&>
operator << (ostream& o, const t &c)
{
    o << c.val() << " ";
    return o;
}

template<typename t, typename b>
ostream& operator << (ostream& o, const pair<t, b> &c)
{

    o << "(" << c.first <<"," << c.second << ") ";
    return o;
}


template<typename t, typename b, typename x>
ostream& operator << (ostream& o, const tuple<t, b, x> &c)
{

    o << "(" << std::get<0>(c) <<"," << std::get<1>(c) << "," << std::get<2>(c) << ") ";
    return o;
}

template<typename t>
typename std::enable_if_t<std::is_void<std::void_t<decltype(std::begin(std::declval<t>())), decltype(std::end(std::declval<t>()))>>::value, std::ostream&>
        operator << (ostream& o, const t &c)
{
    for(size_t i = 0; i < c.size(); i++)
    {
        o << c[i] << " ";
    }
    return o;
}
const int N = 2e5 + 5;

const string yes = "YES";
const string no = "NO";

int a[N][6];
int n, k;

int f[N][1 << 5];

pair<int, int> closed[1 << 5];


int main()
{
#ifdef local
    freopen("in.txt", "r", stdin);
#endif // local
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n >> k;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 0; j < k; j++)
        {
            cin >> a[i][j];
        }
        for(int j = 0; j < (1 << k); j++)
        {
            for(int x = 0; x < k; x++)
            {
                if (j >> x & 1)
                    f[i][j] += a[i][x];
                else f[i][j] -= a[i][x];
            }
        }
    }
    vector<vector<pair<int, int>>> open(1 << k);
    vector<int> bg(1 << k, 0);
    vector<int> del(1 + n, 0);


    for(int j = 0; j < (1 << k); j++)
    {
        closed[j].first = 1;
        closed[j].second = 1;
    }
    for(int i = 2; i <= n; i++)
    {
        for(int j = 0; j < (1 << k); j++)
        {
            open[j].push_back({f[i][j], i});
        }
    }
    vector<int> ed(1 << k, n - 2);

    del[1] = 1;

    for(int j = 0; j < (1 << k); j++)
    {
        sort(open[j].begin(), open[j].end());
    }

    auto getmin = [&](int ind)
    {
        while(del[open[ind][bg[ind]].second])
        {
            bg[ind]++;
        };
        return open[ind][bg[ind]];
    };

    auto getmax = [&](int ind)
    {
        while(del[open[ind][ed[ind]].second])
        {
            ed[ind]--;
        };
        return open[ind][ed[ind]];
    };

    ll ans = 0;
    for(int i = 1; i < n; i++)
    {
        int best = -1;
        int id = 0;
        for(int j = 0; j < (1 << k); j++)
        {
            pair<int, int> minv = { f[closed[j].first][j], closed[j].first};
            pair<int, int> maxv = { f[closed[j].second][j], closed[j].second};

            auto cminv = getmin(j);
            auto cmaxv = getmax(j);


            if (abs(minv.first - cmaxv.first) >= best)
            {
                best = abs(minv.first - cmaxv.first);
                id = cmaxv.second;
            }

            if (abs(minv.first - cminv.first) >= best)
            {
                best = abs(minv.first - cminv.first);
                id = cminv.second;
            }

            if (abs(maxv.first - cminv.first) >= best)
            {
                best = abs(maxv.first - cminv.first);
                id = cminv.second;
            }

            if (abs(maxv.first - cmaxv.first) >= best)
            {
                best = abs(maxv.first - cmaxv.first);
                id = cmaxv.second;
            }
        }
        ans += best;
        for(int j = 0; j < (1 << k); j++)
        {
            if (f[closed[j].first][j] > f[id][j])
            {
                closed[j].first = id;
            }
            if (f[closed[j].second][j] < f[id][j])
            {
                closed[j].second = id;
            }
        }
        del[id] = 1;
    }
    cout << ans << endl;
}