#include <stdio.h>

#define MAX_NUMBER 16

typedef enum {
  row,
  column,
} MatrixVectorType;

typedef struct {
  int rows;
  int columns;
  int elements[MAX_NUMBER][MAX_NUMBER];
} Matrix;

typedef struct {
  MatrixVectorType type;
  int number;
} MatrixVector;


void read_matrix(FILE *f, Matrix *m) {
  int i, j;

  fscanf(f, "%d %d", &m->rows, &m->columns);

  for (i=0; i != m->rows; i++) {
    for (j=0; j != m->columns; j++) {
      fscanf(f, "%d", &m->elements[i][j]);
    }
  }
}

void read_file(const char *path, Matrix *m) {
  FILE *f;

  f = fopen(path, "r");
  read_matrix(f, m);
  fclose(f);
}

void write_file(const char *path, const char *fmt, int number) {
  FILE *f;

  f = fopen(path, "w");
  fprintf(f, fmt, number);
  fclose(f);
}

void write_matrix(FILE *f, Matrix *m) {
  int i, j;

  fprintf(f, "%5d %5d\n", m->rows, m->columns);

  for (i=0; i != m->rows; i++) {
    for (j=0; j != m->columns; j++) {
      fprintf(f, "%5d ", m->elements[i][j]);
    }
    fprintf(f, "\n");
  }
}

void flip(Matrix *m, MatrixVector *vector) {
  int i, j;

  for (i=0; i != m->rows; i++) {
    for (j=0; j != m->columns; j++) {
      if ((vector->type == row && i == vector->number) ||
	  (vector->type == column && j == vector->number)) {
	m->elements[i][j] *= -1;
      }
    }
  }
}

int sum(Matrix *m, MatrixVector *v) {
  int i, j, accumulator;

  accumulator = 0;

  for (i=0; i != m->rows; i++) {
    for (j=0; j != m->columns; j++) {
      if ((v == NULL) ||
	  (v->type == row && v->number == i) ||
	  (v->type == column && v->number == j)) {
	accumulator += m->elements[i][j];
      }
    }
  }

  return accumulator;
}


void find_minimum_vector(Matrix *m, MatrixVector *minimum) {
  int i, min, vector_sum;
  MatrixVector v;

  min = 0;

  for (i=0; i != m->rows; i++) {
    v.type = row;
    v.number = i;
    vector_sum = sum(m, &v);
    if (vector_sum <= min) {
      minimum->type = v.type;
      minimum->number = v.number;
    }
  }

  for (i=0; i != m->columns; i++) {
    v.type = column;
    v.number = i;
    vector_sum = sum(m, &v);
    if (vector_sum <= min) {
      minimum->type = v.type;
      minimum->number = v.number;
    }
  }
}


int maximum_sum(Matrix *m) {
  MatrixVector minimum_vector;
  int minimum, maximum;

  maximum = ~0;
  minimum = 0;

 go:
  find_minimum_vector(m, &minimum_vector);
  minimum = sum(m, &minimum_vector);
  if (minimum < 0) {
    flip(m, &minimum_vector);
    goto go;
  }
  maximum = sum(m, 0);
  return maximum;
}

int main() {
  Matrix m;
  int maximum;

  read_file("flip.in", &m);
  maximum = maximum_sum(&m);
  write_file("flip.out", "%d\n", maximum);

  return 0;
}