/* FILE: domino.cpp
 */

//#include <iostream> 
#include <fstream>
#include <cassert>

using namespace std;

const int UNKNOWN = -1;
int n, k;


/*void display(int val[][3], int n){
        for(int i = 0; i < n; i++){
                cout <<' ';
            for(int j = 0; j < 3; j++){
                cout << val[i][j] <<' ';
            }
                cout <<'\n';
        }

}*/


bool vertic(int a, int b, int c, int d, int e, int f){

        return (((a+d)>(a+b)&&(a+d)>(b+c))||((b+e)>(a+b)&&(b+e)>(b+c))||((c+f)>(a+b)&&(c+f)>(b+c)));
} 

void controlla(int val[][3],int domino[][3], int M[], int i, int n){


int a,b,c,d,e,f; 
int tmp=0;
int j=0;
 for (int g=0; g<n;g++){
        if (M[g]>tmp){
            tmp=M[g];                
            j=g;
        }
    }

bool dom=false,vert=false;
                if (j+1<n){
                a=val[j][0];
                b=val[j][1];
                c=val[j][2];
                d=val[j+1][0];
                e=val[j+1][1];
                f=val[j+1][2];
                }else{
                a=val[j][0];
                b=val[j][1];
                c=val[j][2];
                }

                if (vertic(a, b, c, d, e, f)){
                while((dom==false)){
                if ( (a+d)>(b+e) && (a+d)>(c+f) && domino[j][0]==-1 && domino[j+1][0]==-1){
                        domino[j][0]=i;
                        domino[j+1][0]=i;
                        M[j]=M[j]-val[j][0];
                        M[j+1]=M[j+1] -val[j+1][0];
                        
                        dom=true;
                        

                   }
                if ( (b+e)>(a+d) && (b+b)>(c+f) && domino[j][1]==-1 && domino[j+1][1]==-1){
                        domino[j][1]=i;
                        domino[j+1][1]=i;
                        M[j]=M[j]-val[j][1];
                        M[j+1]=M[j+1] -val[j+1][1];
                        dom=true;
                        

                   }
                if ( (c+f)>(a+d) && (c+f)>(b+e) && domino[j][2]==-1 && domino[j+1][2]==-1){
                        domino[j][2]=i;
                        domino[j+1][2]=i;
                        M[j]=M[j]-val[j][2];
                        M[j+1]=M[j+1] -val[j+1][2];
 
                        dom=true;
                        

                   }
                    dom=true;
                }
                }
                if (M[j]==tmp){
                    dom=false; }                        
                
                while((dom==false)){  

                   if ((a+b)<(b+c) && (b+c)>=(M[j]-a) && domino[j][1]==-1 && domino[j][2]==-1){
                        domino[j][1]=i;
                        domino[j][2]=i;
                        M[j]=M[j]-val[j][1]-val[j][2];
                        dom=true;
                        

                   }
                if  ((a+b)>(b+c) && (a+b)>=(M[j]-c) && domino[j][0]==-1 && domino[j][1]==-1){
                        domino[j][0]=i;
                        domino[j][1]=i;
                        M[j]=M[j]-val[j][0]-val[j][1];
                        dom=true;
                   
                    }

                     }


}



int somma(int D[][3],int V[][3],int n){

int ret=0;
for(int i = 0; i < n; i++){
            
            for(int j = 0; j < 3; j++){
                if (D[i][j]!=-1){
                    ret+=V[i][j];
                }
            }
          }
    return ret;
}



int main() {


        
        ifstream fin("input.txt"); assert( fin );
        fin >> n;
        fin >> k;
        int D[n][3];
        int V[n][3];
        int M[n];

        for(int i = 0; i < n; i++){
            M[i]=0;
            for(int j = 0; j < 3; j++){
                fin >> V[i][j];
                M[i]+=V[i][j];
                D[i][j]=UNKNOWN;
            }
          }
        fin.close();
      /*  display(V,n);
        cout<<'\n';
        cout<<'\n';
        display(D,n);*/

        for (int i=1;i<=k;i++)
            controlla(V,D,M,i,n);
        
   /*         cout<<'\n';
            display(D,n);
    cout<<"Out"<<' '<<somma(D,V,n)<<'\n';*/




  ofstream fout("output.txt"); assert( fout );
 

  fout << somma(D,V,n)<< endl;
  fout.close();
  return 0;
}