You are given a matrix with n rows (numbered from 1 to n) and m columns (numbered from 1 to m). A number a_{i, j} is written in the cell belonging to the i-th row and the j-th column, each number is either 0 or 1.

A chip is initially in the cell (1, 1), and it will be moved to the cell (n, m). During each move, it either moves to the next cell in the current row, or in the current column (if the current cell is (x, y), then after the move it can be either (x + 1, y) or (x, y + 1)). The chip cannot leave the matrix.

Consider each path of the chip from (1, 1) to (n, m). A path is called palindromic if the number in the first cell is equal to the number in the last cell, the number in the second cell is equal to the number in the second-to-last cell, and so on.

Your goal is to change the values in the minimum number of cells so that every path is palindromic.

Input

The first line contains one integer t (1 ≤ t ≤ 200) — the number of test cases.

The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 30) — the dimensions of the matrix.

Then n lines follow, the i-th line contains m integers a_{i, 1}, a_{i, 2}, ..., a_{i, m} (0 ≤ a_{i, j} ≤ 1).

Output

For each test case, print one integer — the minimum number of cells you have to change so that every path in the matrix is palindromic.

Example

Input


4
2 2
1 1
0 1
2 3
1 1 0
1 0 0
3 7
1 0 1 1 1 1 1
0 0 0 0 0 0 0
1 1 1 1 1 0 1
3 5
1 0 1 0 0
1 1 1 1 0
0 0 1 0 0


Output


0
3
4
4

Note

The resulting matrices in the first three test cases:

\begin{pmatrix} 1 & 1\\\ 0 & 1 \end{pmatrix}  \begin{pmatrix} 0 & 0 & 0\\\ 0 & 0 & 0 \end{pmatrix}  \begin{pmatrix} 1 & 0 & 1 & 1 & 1 & 1 & 1\\\ 0 & 1 & 1 & 0 & 1 & 1 & 0\\\ 1 & 1 & 1 & 1 & 1 & 0 & 1 \end{pmatrix} 
/*
                       _oo0oo_
                      o8888888o
                      88" . "88
                      (| -_- |)
                      0\  =  /0
                    ___/`---'\___
                  .' \\|     |// '.
                 / \\|||  :  |||// \
                / _||||| -:- |||||- \
               |   | \\\  -  /// |   |
               | \_|  ''\---/''  |_/ |
               \  .-\__  '-'  ___/-. /
             ___'. .'  /--.--\  `. .'___
          ."" '<  `.___\_<|>_/___.' >' "".
         | | :  `- \`.;`\ _ /`;.`/ - ` : | |
         \  \ `_.   \_ __\ /__ _/   .-` /  /
     =====`-.____`.___ \_____/___.-`___.-'=====
                       `=---='
 
*/
import java.util.function.Consumer;
import java.util.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.io.*;
import java.lang.Math.*;
 public class KickStart2020{
	static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        public FastReader(){br = new BufferedReader(
           new InputStreamReader(System.in));}
        String next(){
            while (st == null || !st.hasMoreElements()) {
                try { st = new StringTokenizer(br.readLine()); }
                catch (IOException e) {e.printStackTrace();}}
            return st.nextToken();}
        int nextInt() { return Integer.parseInt(next()); }
        long nextLong() { return Long.parseLong(next()); }
        double nextDouble() { return Double.parseDouble(next());}
        float nextFloat() {return Float.parseFloat(next());}
        String nextLine() {
            String str = "";
            try {str = br.readLine();}
            catch (IOException e) { e.printStackTrace();}
            return str; }}
	static boolean isBracketSequence(String s, int a, int b) {
		Stack<Character> ss = new Stack<>();
		boolean hachu = true;
		for(int i = a; i <= b; i++) {
			if(s.charAt(i) == ')' && ss.isEmpty()) {hachu = false; break;}
			if(s.charAt(i) == '(') ss.add('(');
			else ss.pop();
		}
		return ss.empty() && hachu;
	}
	static String reverseOfString(String a) {
		StringBuilder ssd = new StringBuilder();
		for(int i = a.length() - 1; i >= 0; i--) {
			ssd.append(a.charAt(i));
		}
		return ssd.toString();
	}
	static ArrayList<Integer> bfs(int n, ArrayList<ArrayList<Integer>> ss){
		ArrayList<Integer> bfs = new ArrayList<>();
		boolean hachu[] = new boolean[n + 1];
		for(int i = 1; i <= n; i++) {
			if(!hachu[i]) {
				Queue<Integer> ssd = new LinkedList<>();
				ssd.add(i);
				hachu[i] = true;
				while(!ssd.isEmpty()) {
					int node = ssd.poll();
					bfs.add(node);
					for(int e: ss.get(node)) {
						if(!hachu[e]) {
							ssd.add(e);
							hachu[e] = true;
						}
					}
				}
			}
		}
		return bfs;
	}
	static void reverseOfArray(int a[]) {
		Stack<Integer> ss = new Stack<Integer>();
		for(int i = 0; i < a.length; i++) ss.push(a[i]);
		for(int i = 0; i < a.length; i++) {
			a[i] = ss.pop();
		}
	}
	static boolean isPalindrome(char a[]) {
		boolean hachu = true;
		for(int i = 0; i <= a.length / 2; i++) {
			if(a[i] != a[a.length - 1 - i]) {
				hachu = false;
				break;
			}
		}
		return hachu;
	} 
	static long gcd(long a, long b)
	{
	    if (b == 0)
	        return a;
	    return gcd(b, a % b);
	     
	}
	static long powermod(long x, long y, long mod){
	    long ans = 1;
	    x = x % mod; 
	    if (x == 0)
	      return 0; 
	    int i = 1;
	    while (y > 0){
	      if ((y & 1) != 0)
	        ans = (ans * x) % mod;
	      y = y >> 1; 
	      x = (x * x) % mod;
	    }
	    return ans;
	  }
	static boolean check(String a) {
		boolean hachu = true;
		for(int i = 0; i < a.length(); i++) {
			if(a.charAt(0) != a.charAt(i)) {hachu = false; break;}
		}
		return hachu;
	}
	static boolean checkArray(int x, int arr[]) {
		boolean hachu = true;
		for(int i = 0; i < arr.length; i++) {
			if(x != arr[i]) {hachu = false; break;}
		}
		return hachu;
	}
	 public static class Pair implements Comparable<Pair> {
	        public  int index;
	        public  int value;
	 
	        public Pair(int index, int value) {
	            this.index = index;
	            this.value = value;
	        }
	        @Override
	        public int compareTo(Pair other) {
	            //multiplied to -1 as the author need descending sort order
	            return   -1 * Integer.valueOf(this.value).compareTo(other.value);
	        }
	 }
	 static boolean equalString(int i, int j, int arr[], String b) {
		 int brr[] = new int[26];
		 for(int k = i; k <= j; k++) brr[b.charAt(k) - 'a']++;
		 for(int k = 0; k < 26; k++) {
			 if(arr[k] != brr[k]) return false;
		 }
		 return true;
	 }
	 static boolean cequalArray(String a, String b) {
		  int count[] = new int[26];
		  int count1[] = new int[26];
		  for(int i = 0; i < a.length(); i++) count[a.charAt(i) - 'a']++;
		  for(int i = 0; i < a.length(); i++) count1[b.charAt(i) - 'a']++;
		  for(int i = 0; i < 26; i++) if(count[i] != count1[i]) return false;
		  return true;
	 }
	 static boolean isPrime(long d) {
		 if(d == 1) return true;
		 for(int i = 2; i <= (long)Math.sqrt(d); i++) {
			 if(d % i == 0) return false;
		 }
		 return true;
	 }
	 static String decimalTob(int n, int b, String g) {
		  int z = n % b;
		  g = String.valueOf(z) + g;
		  n /= b;
		  if(n > 0) {
			  g = decimalTob(n, b, g);
		  }
		  return g;
	 }
		public static void main(String[] args) throws Exception{
			FastReader sc = new FastReader();
			PrintWriter out = new PrintWriter(System.out);
               int  t = sc.nextInt();
               while(t-- > 0) {
               int n = sc.nextInt();
               int m = sc.nextInt();
               int arr[][] = new int[n][m];
               int steps[][] = new int[n + m][2];
               int run[][] = new int[n][m];
               for(int i = 0; i < n; i++) 
            	   for(int j = 0; j < m; j++) 
            		   arr[i][j] = sc.nextInt();
               for(int i = 0; i < n; i++) 
            	   for(int j = 0; j < m; j++) {
            		   if(j == 0) {
            			   if(i == 0) {
            				   run[i][j] = 0;
            			   }
            			   else run[i][j] = run[i - 1][j] + 1;
            		   }
            		   else {
            			   run[i][j] = run[i][j - 1] + 1;
            		   }
            	   }
                  for(int i = 0; i < n; i++) {
                	  for(int j = 0; j < m; j++) {
                		  steps[run[i][j]][arr[i][j]]++;
                	  }
                  }
                  int count = 0;
                  for(int i = 0, j = n + m - 2; i < j; i++, j--) {
                	  count += Math.min(steps[i][0] + steps[j][0], steps[i][1] + steps[j][1]);
                  }
                  out.println(count);
               }
                 out.close();
			}
		}