CF_stupid

use std::fmt::Debug;
use std::io;
use std::num::ParseIntError;
use std::str::FromStr;

#[inline]
fn input<T: FromStr<Err = ParseIntError> + Debug>() -> T {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    input.trim().parse().unwrap()
}

#[inline]
fn input_vec<T: FromStr<Err = ParseIntError> + Debug>() -> Vec<T> {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    input
        .split_ascii_whitespace()
        .map(|x| x.parse::<T>().unwrap())
        .collect()
}

#[inline]
fn input_pair<T: FromStr<Err = ParseIntError> + Debug>() -> (T, T) {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();

    let mut input = input.split_ascii_whitespace();
    (
        input.next().unwrap().parse().unwrap(),
        input.next().unwrap().parse().unwrap(),
    )
}

#[inline]
fn remake(i: usize, q: usize, i_: usize, q_: usize, vec: &mut Vec<Vec<i32>>) {
    unsafe {
        *vec.get_unchecked_mut(i).get_unchecked_mut(q) = -*vec.get_unchecked(i).get_unchecked(q);
        *vec.get_unchecked_mut(i_).get_unchecked_mut(q_) =
            -*vec.get_unchecked(i_).get_unchecked(q_);
    }
}

fn change(
    i: usize,
    q: usize,
    n: usize,
    m: usize,
    vec: &mut Vec<Vec<i32>>,
    map: &mut Vec<(i32, usize, usize)>,
) -> bool {
    unsafe {
        if *vec.get_unchecked(i).get_unchecked(q) < 0 {
            if i > 0 {
                remake(i, q, i - 1, q, vec);
                return true;
            }

            if i + 1 < n {
                if *vec.get_unchecked(i + 1).get_unchecked(q) <= 0 {
                    remake(i, q, i + 1, q, vec);
                    return true;
                }
            }

            if q > 0 {
                if *vec.get_unchecked(i).get_unchecked(q - 1) <= 0 {
                    remake(i, q, i, q - 1, vec);
                    return true;
                }
            }

            if q + 1 < m {
                if *vec.get_unchecked(i).get_unchecked(q + 1) <= 0 {
                    remake(i, q, i, q + 1, vec);
                    return true;
                }
            }

            let mut min = Vec::with_capacity(4);

            if i > 0 {
                min.push(*vec.get_unchecked(i - 1).get_unchecked(q));
            }

            if i + 1 < n {
                min.push(*vec.get_unchecked(i + 1).get_unchecked(q));
            }

            if q > 0 {
                min.push(*vec.get_unchecked(i).get_unchecked(q - 1));
            }

            if q + 1 < m {
                min.push(*vec.get_unchecked(i).get_unchecked(q + 1));
            }

            min.sort();

            let x = *min.get_unchecked(0);

            if (*vec.get_unchecked_mut(i).get_unchecked_mut(q)).abs() > x {
                if i > 0 {
                    if *vec.get_unchecked(i - 1).get_unchecked(q) == x {
                        remake(i, q, i - 1, q, vec);
                        map.push((*vec.get_unchecked(i - 1).get_unchecked(q), i - 1, q));
                        map.sort_by(|x, y| (x.0).partial_cmp(&y.0).unwrap());
                        return true;
                    }
                }

                if i + 1 < n {
                    if *vec.get_unchecked(i + 1).get_unchecked(q) == x {
                        remake(i, q, i + 1, q, vec);
                        map.push((*vec.get_unchecked(i + 1).get_unchecked(q), i + 1, q));
                        map.sort_by(|x, y| (x.0).partial_cmp(&y.0).unwrap());
                        return true;
                    }
                }

                if q > 0 {
                    if *vec.get_unchecked(i).get_unchecked(q - 1) == x {
                        remake(i, q, i, q - 1, vec);
                        map.push((*vec.get_unchecked(i).get_unchecked(q - 1), i, q - 1));
                        map.sort_by(|x, y| (x.0).partial_cmp(&y.0).unwrap());
                        return true;
                    }
                }

                if q + 1 < m {
                    if *vec.get_unchecked(i).get_unchecked(q + 1) == x {
                        remake(i, q, i, q + 1, vec);
                        map.push((*vec.get_unchecked(i).get_unchecked(q + 1), i, q + 1));
                        map.sort_by(|x, y| (x.0).partial_cmp(&y.0).unwrap());
                        return true;
                    }
                }
            }

            return false;
        }
        return true;
    }
}

fn main() {
    let t = input::<i32>();

    for _ in 0..t {
        let (n, m) = input_pair::<usize>();

        let mut vec = vec![vec![0; m]; n];

        for i in &mut vec {
            *i = input_vec::<i32>();
        }

        let mut map = Vec::<(i32, usize, usize)>::new();

        for i in 0..n {
            for q in 0..m {
                unsafe {
                    if *vec.get_unchecked(i).get_unchecked(q) < 0 {
                        map.push((*vec.get_unchecked(i).get_unchecked(q), i, q));
                    }
                }
            }
        }

        map.sort_by(|x, y| (x.0).partial_cmp(&y.0).unwrap());

        let mut ch = true;

        while !map.is_empty() {
            unsafe {
                let b = change(
                    map.get_unchecked(0).1,
                    map.get_unchecked(0).2,
                    n,
                    m,
                    &mut vec,
                    &mut map,
                );

                if !b && !ch {
                    break;
                }

                ch = b;
                map.remove(0);
            }
        }

        let mut sum = 0_i128;

        for i in 0..n {
            for q in 0..m {
                unsafe {
                    sum += *vec.get_unchecked(i).get_unchecked(q) as i128;
                }
            }
        }

        println!("{}", sum);
    }
}