#include <iostream>
#include <fstream>
#include <algorithm>
#include <math.h>
#include <climits>

using namespace std;

class Board {
private:
    long long int board[16][16];
    int noOfLines;
    int noOfColumns;
public:
    Board(int noOfLines, int noOfColumns);

    void setValue(long long int value, int line, int column);

    long long int getValue(int line, int column);

    long long int sum();

    void flipColumn(int column);

    void flipLine(int line);

    void display();

    int getNoOfLines();

    int getNoOfColumns();

    long long int getColumnSum(int column);

    Board &operator=(const Board boardToCopy);

};

Board::Board(int noOfLines, int noOfColumns) {
    this->noOfLines = noOfLines;
    this->noOfColumns = noOfColumns;
}

int Board::getNoOfLines() {
    return this->noOfLines;
}

int Board::getNoOfColumns() {
    return this->noOfColumns;
}

void Board::flipColumn(int column) {
    for (int it = 0; it < noOfLines; it++) {
        this->board[it][column] *= -1;
    }
}

void Board::flipLine(int line) {
    for (int it = 0; it < this->noOfColumns; it++) {
        this->board[line][it] *= -1;
    }
}

void Board::display() {
    for (int lineIterator = 0; lineIterator < this->noOfLines; lineIterator++) {
        cout << "\n";
        for (int columnIterator = 0; columnIterator < this->noOfColumns; columnIterator++) {
            cout << this->board[lineIterator][columnIterator] << " ";
        }
    }
}

void Board::setValue(long long int value, int line, int column) {
    this->board[line][column] = value;
}

long long int Board::getColumnSum(int column) {
    long long int sum = 0;
    for (int it = 0; it < noOfLines; it++) {
        sum += this->board[it][column];
    }

    return sum;
}

Board &Board::operator=(Board boardToCopy) {
    if (this != &boardToCopy) {
        this->noOfLines = boardToCopy.getNoOfLines();
        this->noOfColumns = boardToCopy.getNoOfColumns();
        for (int lineIt = 0; lineIt < this->noOfLines; ++lineIt) {
            for (int columnIt = 0; columnIt < this->noOfColumns; ++columnIt) {
                this->setValue(boardToCopy.getValue(lineIt, columnIt), lineIt, columnIt);
            }
        }

    }

    return *this;
}

long long int Board::getValue(int line, int column) {
    return this->board[line][column];
}

long long int Board::sum() {
    long long int accumulator = 0;
    for (int lineIterator = 0; lineIterator < this->noOfLines; lineIterator++) {
        for (int columnIterator = 0; columnIterator < this->noOfColumns; columnIterator++) {
            accumulator += this->board[lineIterator][columnIterator];
        }
    }
    return accumulator;
}

int main() {
    int noOfColumns = 0, noOfLines = 0;
    ifstream inputFile;

    inputFile.open("flip.in", ifstream::in);
    if (!inputFile.is_open()) {
        cout << "Input file is not opened";
        return -1;
    }
    inputFile >> noOfLines >> noOfColumns;

    Board *initialBoard = new Board(noOfLines, noOfColumns);
    for (int lineIterator = 0; lineIterator < noOfLines; lineIterator++) {
        for (int columnIterator = 0; columnIterator < noOfColumns; columnIterator++) {
            long long int value = 0;
            inputFile >> value;
            initialBoard->setValue(value, lineIterator, columnIterator);
        }
    }
    long long int maxSum = LLONG_MIN;
    for (int iterator = 1; iterator < (int) pow(2, noOfLines); iterator++) {
        Board *copyBoard = new Board(noOfLines, noOfColumns);
        *copyBoard = *initialBoard;
        for (int lineIt = 0; lineIt < noOfLines; lineIt++) {
            if (((iterator >> lineIt) & 1) == 1) {
                copyBoard->flipLine(lineIt);
            }
        }

        for (int columnIterator = 0; columnIterator < noOfColumns; columnIterator++) {
            if (copyBoard->getColumnSum(columnIterator) < 0) {
                copyBoard->flipColumn(columnIterator);
            }
        }

        long long int currentSum = copyBoard->sum();
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }

        delete copyBoard;
    }

    ofstream outputFile;
    outputFile.open("flip.out", ofstream::out);
    if (!outputFile.is_open()) {
        cout << "Output file is not opened";
        return -1;
    }

    outputFile << maxSum;

    return 0;
}