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

#include <chrono>
#include <vector>

const int MAX_SIZE = 16;


int board[MAX_SIZE][MAX_SIZE] = {0};
int M, N;


int sum_column(int number) {
    int sum = 0;
    for (auto &i: board) {
        sum += i[number];
    }
    return sum;
}

int get_sum() {
    int sum = 0;
    for (const auto &row: board) {
        for (const auto &col: row) {
            sum += col;
        }
    }
    return sum;
}

int flipped_columns[MAX_SIZE] = {0};
int flipped_lines[MAX_SIZE] = {0};

void flip_line(int line_number, int direction) {
    if (direction == 1) {
        if (flipped_lines[line_number] == 1) {
            return;
        }

        flipped_lines[line_number] = 1;
        for (int i = 0; i < N; ++i) {
            board[line_number][i] *= -1;
        }
    } else {
        if (flipped_lines[line_number] == 0) {
            return;
        }

        flipped_lines[line_number] = 0;
        for (int i = 0; i < N; ++i) {
            board[line_number][i] *= -1;
        }
    }
}

void flip_column(int column_number) {
    for (auto &i: board) {
        i[column_number] *= -1;
    }
}

void print_matrix() {
    std::cout << "\n<------------------->\n";
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            std::cout << board[i][j] << " ";
        }
        std::cout << '\n';

    }
}

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);

    input_file >> M >> N;

    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            input_file >> board[i][j];
        }
    }

    int limit = 1 << M;
    int max_sum = 0;
    std::vector<int> flipped_columns;

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

        for (int k = 0; k < N; ++k) {
            if (sum_column(k) < 0) {
                flip_column(k);
                flipped_columns.push_back(k);
            }
        }

        int new_sum = get_sum();
        if (new_sum > max_sum) {
            max_sum = new_sum;
        }
        while (!flipped_columns.empty()) {
            flip_column(flipped_columns.back());
            flipped_columns.pop_back();
        }
//        for (int j = 0; j < N; ++j) {
//            flip_column(j, 0);
//        }
    }

    std::ofstream out;
    out.open(output_file_name);
    out << max_sum;
    return 0;
}

int main() {

    using namespace std;
    using namespace std::chrono;

    auto start = high_resolution_clock::now();
    flip_algo();
    auto stop = high_resolution_clock::now();
    auto duration = duration_cast<milliseconds>(stop - start);
    cout << duration.count() << endl;
}