#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <iostream>
#include <vector>
#include <set>
#include <regex>
#include <boost/format.hpp>

using namespace std;

#define FOR(i, a, b) for (auto i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define DEBUG(_debuged) cerr << #_debuged << ":" << _debuged << endl;

struct L
{
    int t;
    int x;
    int y;
};

vector<int> loadn(int n)
{
    vector<int> v(n);
    REP(i, n)
    cin >> v[i];
    return v;
}

uint64_t modpower(const unsigned int N, const unsigned int K, const unsigned int MOD)
{
    uint64_t ret = 1;
    uint64_t k2 = N;
    REP(i, 31)
    {
        if ((K >> i) & 0x1)
        {
            ret *= k2;
            ret = ret % MOD;
        }
        k2 = (k2 * k2) % MOD;
    }
    return ret;
}

class ModCombinationMemo
{
  public:
    const unsigned int N;
    const unsigned int MOD;
    vector<uint64_t> memo = {1};

    ModCombinationMemo(uint32_t N, uint32_t MOD)
        : N(N), MOD(MOD)
    {
    }

    uint64_t c(uint64_t k)
    {
        if (memo.size() > k)
        {
            return memo[k];
        }

        FOR(i, memo.size(), k + 1)
        {
            const auto number = (memo[i - 1] * (N - i + 1)) % MOD;
            const auto reverceDeon = modpower(i, MOD - 2, MOD);
            memo.push_back(number * reverceDeon % MOD);
        }

        return memo[k];
    }
};

uint64_t c(const unsigned int N, const unsigned int K, const unsigned int MOD)
{
    if (K == 0)
    {
        return 1;
    }

    uint64_t n = 1, k = 1;

    REP(i, K)
    {
        n *= N - i;
        k *= i + 1;

        n = n % MOD;
        k = k % MOD;
    }

    uint64_t powerk = modpower(k, MOD - 2, MOD);

    return (n * powerk) % MOD;
}

unsigned trailing_zeros(unsigned n)
{
    if (!n)
        return -1;
    unsigned int c = 32; // c will be the number of zero bits on the right
    n &= -(signed)n;
    if (n)
        c--;
    if (n & 0x0000FFFF)
        c -= 16;
    if (n & 0x00FF00FF)
        c -= 8;
    if (n & 0x0F0F0F0F)
        c -= 4;
    if (n & 0x33333333)
        c -= 2;
    if (n & 0x55555555)
        c -= 1;
    return c;
}

struct oishisa
{
    int64_t x;
    int64_t y;
    int64_t z;
};

int main(int argc, char *argv[], char *envp[])
{
    int N, M; cin >> N >> M;
    vector<oishisa> v;

    REP(i, N)
    {
        oishisa o;
        cin >> o.x >> o.y >> o.z;
        v.push_back(o);
    }

    int64_t m = LLONG_MIN;
    REP(xStrategy, 2) REP(yStrategy, 2) REP(zStrategy, 2) {
        const int64_t xSign = xStrategy ? -1 : +1;
        const int64_t ySign = yStrategy ? -1 : +1;
        const int64_t zSign = zStrategy ? -1 : +1;

        sort(v.begin(), v.end(), [=](const oishisa &l, const oishisa &r) {
            return (
                (l.x - r.x) * xSign + (l.y - r.y) * ySign + (l.z - r.z) * zSign
            ) > 0;
        });

        int64_t xTotal = 0, yTotal = 0, zTotal = 0;
        REP(i, M) {
            xTotal += v[i].x;
            yTotal += v[i].y;
            zTotal += v[i].z;
        }
        auto score = abs(xTotal) + abs(yTotal) + abs(zTotal);
        m = max(abs(xTotal) + abs(yTotal) + abs(zTotal), m);
    }

    cout << m << endl;
}


Measured memory_bytes: 256