#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

enum Direction {
    positive, negative
};

class Board {
private:
    std::vector<std::vector<int>> internal_board;
    Direction line_direction[16] = {positive};
    Direction column_direction[16] = {positive};

    int sum_c[16] = {0};
    int total_sum = 0;

    void update_sums() {
        for (unsigned int  i = 0; i < internal_board[0].capacity(); ++i) {
            sum_c[i] = sum_col(i);
            total_sum += sum_c[i];
        }
    }

public:
    explicit Board(std::vector<std::vector<int>> matrix) {
        internal_board = std::move(matrix);
        update_sums();
    }

    void flip_line(int number) {
        for (unsigned int i = 0; i < internal_board[0].capacity(); ++i) {
            internal_board[number][i] *= -1;
            sum_c[i] += 2 * internal_board[number][i];
            total_sum += 2 * internal_board[number][i];
        }
//        for (auto &col: internal_board[number]) {
//            col *= -1;
//        }
    }

    void flip_column(int number) {
        for (auto &row: internal_board) {
            row[number] *= -1;
        }
        sum_c[number] *= -1;
        total_sum += 2 * sum_c[number];
    }

    void flip_line(int number, Direction direction) {
        if (direction != line_direction[number]) {
            line_direction[number] = direction;
            flip_line(number);
        }
    }

    void flip_column(int number, Direction direction) {
        if (direction != column_direction[number]) {
            column_direction[number] = direction;
            flip_column(number);
        }
    }

    void print_matrix() {
        std::cout << "\n<------------------->\n";

        for (const auto &row: internal_board) {
            for (const auto &col: row) {
                std::cout << col << " ";
            }
            std::cout << '\n';
        }
    }

    int get_sum() {
        int sum = 0;

        for (const auto &row: internal_board) {
            for (const auto &col: row) {
                sum += col;
            }
        }

        return sum;
    }

    int sum_line(int number) {
        int sum = 0;

        for (const auto &col: internal_board[number]) {
            sum += col;
        }

        return sum;
    }

    int sum_col(int number) {
        int sum = 0;

        for (const auto &row: internal_board) {
            sum += row[number];
        }

        return sum;
    }

    void print_sum() {
        std::cout << '\n' << get_sum() << '\n';
    }

    int get_col_sum(int col_number) {
        return sum_c[col_number];
    }

    int get_internal_sum() const {
        return total_sum;
    }
};

int flip_algo() {
    std::string input_file_name("../flip.in");
    std::string output_file_name("../flip.out");

    std::ifstream input_file;
    input_file.open(input_file_name);

    int M, N;
    input_file >> M >> N;

    auto matrix = std::vector<std::vector<int>>(M);

    for (auto &row: matrix) {
        row = std::vector<int>(N);

        for (auto &col: row) {
            input_file >> col;
        }
    }

    auto game = new Board(matrix);

    int limit = 1 << M;
    int max_sum = 0;


    auto tmp_game = game;

    for (int i = 0; i < limit; ++i) {
        for (int j = 0; 1 << j <= i; ++j) {
            if (i & (1 << j)) {
                tmp_game->flip_line(j, negative);
            } else {
                tmp_game->flip_line(j, positive);
            }
        }

        for (int k = 0; k < N; ++k) {
            if (tmp_game->get_col_sum(k) < 0) {
                tmp_game->flip_column(k);
            }
        }

//        int new_sum = tmp_game->get_sum();
        int new_sum = tmp_game->get_internal_sum();

        if (new_sum > max_sum) {
            max_sum = new_sum;
        }
    }


    std::ofstream out;
    out.open(output_file_name);

    out << max_sum;
    return 0;
}

int main() {
    flip_algo();
}