#include<stdio.h>
#include<stdlib.h>

int nCols;
int nRows;

struct data{
		int index;
		int sum;
	};
int computeAproxAverage(struct data *array){
    int sum = 0;
    int n = sizeof(array)/sizeof(array[0]);
    for(int i = 0; i < n; i++){
        sum += array[i].sum;
    }
     
    return sum/n;
}

int computeTotalSum(int table[16][16]){

	int sum = 0;

		for(int i = 0; i < nCols; i++)
		for(int j = 0; j < nRows; j++)
			sum += table[j][i];
	
	return sum;
	}

int computeCollumnSum(int table[16][16], int coll){
	
	int sumColl = 0;
	
		for(int i = 0; i < nRows; i++)
			sumColl += table[i][coll];
				
	  return sumColl;	
	}

int computeRowSum(int table[16][16], int row){
	
	int sumRow = 0;
		
		for(int i = 0; i < nCols; i++)
			sumRow += table[row][i];
			
	return sumRow;
	}


int cmpfunc(const void *p, const void *q) 
{
    int l = ((struct data *)p)->sum;
    int r = ((struct data *)q)->sum; 
    return (l - r);
}

void createArrayOfSumRow(struct data *arr, int table[16][16]){
	
		for(int i = 0; i < nRows; i++){
			arr[i].sum = computeRowSum(table, i);
			arr[i].index = i ;
		}
		
		qsort(arr, nRows, sizeof(struct data), cmpfunc);
	}
	
void createArrayOfSumColl(struct data *arr, int table[16][16]){
	
		for(int i = 0; i < nCols; i++){
			arr[i].sum = computeCollumnSum(table, i);
			arr[i].index = i ;
		}
		
		qsort(arr, nCols, sizeof(struct data), cmpfunc);
	}
	
void createArrayOfMinSumIndex(int dimArr,struct data *arr, int *idxArr, int *size, int cmp){
	//dimArr - dimensiunea tabloului de elemente pe Line sau coloana
	//arr - tablul de date
	//idxArr - tabloul de date umplum cu indexi 
	//*size - un pointer care retine dimensiunea tabloului de indexi format
	//cmp - comparator
	*size = 0;
		for(int i = 0; i < dimArr; i++){
				if(arr[i].sum <= cmp){
					
						idxArr[*size] = arr[i].index;
						(*size)++;
					}
			}
	 //printf("\n%d", *size);
	}

void modifieTableRow(int table[16][16], int *idxArr){
	int n = sizeof(idxArr)/sizeof(idxArr[0]);
			for(int i = 0 ; i < n-1; i++)
				{for(int j = 0; j < nCols; j++)
					table[idxArr[i]][j] = (-1) * table[idxArr[i]][j];
					
				}
	}

void modifieTableColl(int table[16][16], int *idxArr){
	int n = sizeof(idxArr)/sizeof(idxArr[0]);
		for(int i = 0 ; i < n-1; i++)
				{for(int j = 0; j < nRows; j++)
				
					table[j][idxArr[i]] = (-1) * table[j][idxArr[i]];
				}
	}


int main(){
		FILE *input = fopen("flip.in", "r");
		FILE *out = fopen("flip.out", "w");
		fscanf(input, "%d %d", &nRows, &nCols);
		int table[16][16];
		int indexRow[16];
		int indexColl[16];
	
		struct data sumRow[16];
		struct data sumColl[16];
		int sumMatrix = 0;
		int coll = 0;
		int row = 0;

		//read table
		for(int i = 0; i < nRows; i++)
		for(int j = 0; j < nCols; j++){
			fscanf(input, "%d", &table[i][j]);
		}
	    
		//sumRow array
		createArrayOfSumRow(sumRow, table);
		//find index of minim sumRow
		createArrayOfMinSumIndex(nRows,sumRow, indexRow, &row, computeAproxAverage(sumRow));
	  
		//modif row
		modifieTableRow(table, indexRow);
		
	    //sumColl array
	    createArrayOfSumColl(sumColl, table);
	    //find index of min sumColl
		createArrayOfMinSumIndex(nCols, sumColl, indexColl, &coll, computeAproxAverage(sumColl));
	    
	    //modif row
		modifieTableColl(table, indexColl);
	
		sumMatrix = computeTotalSum(table);
	    
	    fprintf(out, "%d", sumMatrix);
			
fclose(input);	
fclose(out);			
	return 0;}