struct InputData {
    a: Vec<Vec<i32>>,
    n:usize,
    m:usize,
    inverse_line: Vec<bool>,
    inverse_col: Vec<bool>
}
impl InputData {
    fn new(a: Vec<Vec<i32>>, n:usize, m:usize) -> InputData {
        InputData {a, n, m, inverse_line:vec![false; n], inverse_col:vec![false; m]}
    }
    fn get_sum_col(&self, col:usize) -> i32{
        let mut sum = 0;
        for i in 0..self.n {
            if self.inverse_line[i] ^ self.inverse_col[col] {
                sum += self.a[i][col];
            }
            else{
                sum -= self.a[i][col];
            }
        }
        sum
    }
    fn invert_line(&mut self, line:usize) {
        self.inverse_line[line] = true;
    }
    fn invert_col(&mut self, col:usize) {
        self.inverse_col[col] = true;
    }
    fn improve_on_col(&mut self) {
        for j in 0..self.m {
            if self.get_sum_col(j) < 0 {
                self.invert_col(j);
            }
        }
    }
    fn solve(&mut self) -> i32{
        let pow_16:i32 = 1 << self.n;
        let mut rez = 0;
        for i in 0..pow_16 {
            //println!("i:{}", i);
            for j in 0..self.n {
                if i & (1 << j) != 0 {
                    self.invert_line(j);
                }
            }
            self.improve_on_col();

            let mut val = 0;
            for j in 0..self.m {
                val += self.get_sum_col(j);
            }
            if rez < val {
                rez = val;
            }
            
            for i in 0..self.n {
                self.inverse_line[i] = false;
            }
            for j in 0..self.m {
                self.inverse_col[j] = false;
            }
        }
        rez
    }
}
fn read_input_data() -> InputData {
    let file_content = std::fs::read_to_string("flip.in").unwrap();
    let file_lines = file_content.split_whitespace().collect::<Vec<&str>>();
    let n = file_lines[0].parse::<usize>().unwrap();
    let m = file_lines[1].parse::<usize>().unwrap();
    let mut a: Vec<Vec<i32>> = vec![vec![0; m]; n];
    {
        let mut number = 2;
        for i in 0..n {
            for j in 0..m {
                a[i][j] = file_lines[number].parse::<i32>().unwrap();
                number += 1;
            }
        }
    }
    InputData::new(a, n, m)
}
fn main() {
    let mut input_data: InputData = read_input_data();
    let sol = input_data.solve();
    std::fs::write("flip.out", format!("{}", sol)).unwrap();
}