import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

/**
 * ACM Training 2009
 * ACM Problem #167 - Sultan's Successors
 * Link: http://uva.onlinejudge.org/external/1/167.html
 *
 * @author Felix Dietrich
 * @version 1.0, 08/31/2009
 *
 * Methode: Backtracking
 * Status : Accepted
 * Runtime: 0.200
 */

public class Main
{
    public static void main(String... str) throws NumberFormatException, IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //br = new BufferedReader(new FileReader("testfile.txt"));
        
        // get the number of boards following
        int boards = Integer.parseInt(br.readLine());
        // the sums of the numbers in one board
        List<Integer> sums = new ArrayList<Integer>();
        String input;
        StringTokenizer st;
        
        // backtrack all queens solutions
        track(new ArrayList<Integer>(), 0);
        
        //for each board, sum up the numbers and find the maximum
        while(boards > 0)
        {
            input = br.readLine();
            if(input.length() > 0)
            {
                sums.clear();
                
                // read the board. the first line is already read (in input)
                for(int i=0; i<8; i++)
                {
                    st = new StringTokenizer(input);
                    int[] numbers = new int[8];
                    
                    for(int k=0;k<8;k++)
                        numbers[k] = Integer.parseInt(st.nextToken());
                    
                    // for every possible queen formation, add the number in sums
                    for(int k=0; k<solutions.size(); k++)
                    {
                        if(sums.size()<=k)
                        {
                            sums.add(k, 0);
                            sums.set(k, 0+numbers[solutions.get(k).get(i)]);
                        }
                        else
                            sums.set(k, sums.get(k)+numbers[solutions.get(k).get(i)]);
                    }
                    
                    if(i<7)
                        input = br.readLine();
                }
                
                // print the maximum sum
                System.out.println(String.format("%5d", Collections.max(sums)));
                
                boards--;
            }
        }
    }

    private static List<List<Integer>> solutions = new ArrayList<List<Integer>>();
    
    /**
     * Backtracks all possible solutions for the 8 queens problem.
     * @return a list of queen solutions
     */
    private static void track(List<Integer> mySolution, int row)
    {
        if(row >= 8)
        {
            solutions.add(mySolution);
            return;
        }
            
        for(int col=0; col<8; col++)
        {
            if(possibleSolution(mySolution, row, col))
            {
                List<Integer> s = new ArrayList<Integer>(mySolution);
                s.add(col);
                track(s, row + 1);
            }
        }
    }

    // checks if the row and col number are valid (can be added to the given solution)
    private static boolean possibleSolution(List<Integer> mySolution, int row, int col)
    {
        for(int localRow=0; localRow<mySolution.size(); localRow++)
        {
            // compare columns, rows and diagonals
            if(mySolution.get(localRow) == col
                    || localRow == row
                    || Math.abs(localRow-row) == Math.abs(mySolution.get(localRow)-col))
            {
                return false;
            }
        }
        
        return true;
    }
}