hdu5942

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NavigableSet;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main {

    public static void main(String[] args) throws IOException{

           StreamTokenizer cin = new StreamTokenizer(new BufferedInputStream(System.in)); 
           InputReader in = new InputReader(System.in)  ;
           PrintWriter out = new PrintWriter(System.out) ;  
           int t = in.nextInt() ;
           for(int cas = 1 ; cas <= t ; cas++){
                out.print("Case #" + cas + ": ") ;
                new Task().solve(in ,  out) ;   
           }
           out.flush();
    }

}

class  Task{

    static int[][] val = new int[31][31] ;
    static int[][][] dp = new int[31][31][60*30] ;

    public void solve(InputReader in , PrintWriter out){
           int n = in.nextInt() ;
           int m = in.nextInt() ;
           for(int i = 1 ; i <= n ; i++){
                for(int j = 1 ; j <= m ; j++) val[i][j] = in.nextInt() ;
           }

           for(int i = 1 ; i <= n ; i++)
                for(int j = 1 ; j <= m ; j++) Arrays.fill(dp[i][j] , Integer.MAX_VALUE) ;

           dp[1][1][val[1][1]] = val[1][1] * val[1][1] ;

           int N = (n+m-1) * 30 ;
           for(int i = 1 ; i <= n ; i++){
                for(int j = 1 ; j <= m ; j++){
                     if(j+1 <= m){
                          int v = val[i][j+1] ;
                          for(int k = 0 ; k + v <= N ; k++){
                               if(dp[i][j][k] != Integer.MAX_VALUE)
                                  dp[i][j+1][k+v] = Math.min(dp[i][j+1][k+v], dp[i][j][k]+v*v) ;
                          }
                     }
                     if(i+1 <= n){
                          int v = val[i+1][j] ;
                          for(int k = 0 ; k + v <= N ; k++){
                               if(dp[i][j][k] != Integer.MAX_VALUE)
                                  dp[i+1][j][k+v] = Math.min(dp[i+1][j][k+v], dp[i][j][k]+v*v) ;
                          }
                     }
                }
           }

           int ans = Integer.MAX_VALUE ;
           for(int k = 0 ; k <= N ; k++){
                 if(dp[n][m][k] != Integer.MAX_VALUE){
                        ans = Math.min(ans , dp[n][m][k]*(n+m-1) - k*k) ;
                 }
           }
           out.println(ans) ;
    }
}


class   InputReader{
        public BufferedReader  reader;
        public StringTokenizer  tokenizer;

        public InputReader(InputStream stream){
               reader = new BufferedReader(new InputStreamReader(stream), 32768) ;
               tokenizer = null ;
        }

        public String next(){
               while(tokenizer == null || ! tokenizer.hasMoreTokens()){
                        try{
                            tokenizer = new StringTokenizer(reader.readLine());
                        }catch (IOException e) {
                             throw new RuntimeException(e);
                        }
               }
               return tokenizer.nextToken();  
        }

        public int  nextInt(){
                    return Integer.parseInt(next());
        }

        public long nextLong(){
                    return Long.parseLong(next());
        }

        public double nextDouble(){
                    return  Double.parseDouble(next());
        }

}