import java.io.*;
import java.util.*;

public class Solution
{
    public static void main(String[] args)
    {
        int a[][] = new int[6][6];
        int maxSum = Integer.MIN_VALUE;
        try (Scanner scanner = new Scanner(System.in);)
        {
            for(int i = 0; i < 6; i++)
            {
                for(int j = 0; j < 6; j++)
                {
                    a[i][j] = scanner.nextInt();
                    if (i > 1 && j > 1)
                    {
                        int sum =
                            a[i][j]
                            + a[i][j-1]
                            + a[i][j-2]
                            + a[i-1][j-1]
                            + a[i-2][j]
                            + a[i-2][j-1]
                            + a[i-2][j-2];
                        if (sum > maxSum) {maxSum = sum;}
                    }
                }
            }
        }
        System.out.println(maxSum);
    }
}

import java.util.Scanner;

public class Solution {

    public static void main(String [] args) {
        Scanner scan = new Scanner(System.in);
        int arr[][] = new int[6][6];
        for (int row = 0; row < 6; row++) {
            for (int col = 0; col < 6; col++) {
                arr[row][col] = scan.nextInt();
            }
        }
        scan.close();
        
        System.out.println(maxHourglass(arr));
    }
    
    public static int maxHourglass(int [][] arr) {
        int max = Integer.MIN_VALUE;
        for (int row = 0; row < 4; row++) {
            for (int col = 0; col < 4; col++) {
                int sum = findSum(arr, row, col);
                max = Math.max(max, sum);
            }
        }
        return max;
    }
    
    private static int findSum(int [][] arr, int r, int c) {
        int sum = arr[r+0][c+0] + arr[r+0][c+1] + arr[r+0][c+2]
                                + arr[r+1][c+1] + 
                  arr[r+2][c+0] + arr[r+2][c+1] + arr[r+2][c+2];
        return sum;
    }
}

    // Approach 1: explicitly add the array values (TIED FASTEST)
    private static int solve1(int[][] arr) {

        int maxValue = Integer.MIN_VALUE;
        int width = arr[0].length - 2;

        for (int row = 0; row < arr.length - 2; row++) {
            for (int col = 0; col < width; col++) {

                maxValue = Math.max(maxValue,
                        arr[row][col] + arr[row][col+1] + arr[row][col+2] +
                        arr[row + 1][col + 1] +
                        arr[row+2][col] + arr[row+2][col+1] + arr[row+2][col+2]);
            }
        }
        return maxValue;
    }

    // Approach 2: Inner loop to sum top/bottom rows (2ND FASTEST)
    private static int solve2(int[][] arr) {

        int maxValue = Integer.MIN_VALUE;
        int width = arr[0].length - 2;

        int total = 0;
        for (int row = 0; row < arr.length - 2; row++) {
            for (int col = 0; col < width; col++) {

                total = arr[row + 1][col + 1]; // center
                for (int pos = col; pos < col + 3; pos++) {
                    // add the top/bottom rows
                    total += arr[row][pos] + arr[row + 2][pos];
                }

                maxValue = Math.max(maxValue, total);
            }
        }
        return maxValue;
    }

    // Approach 3: Use streams to sum top/bottom rows (2ND SLOWEST)
    private static int solve3(int[][] arr) {
        int maxValue = Integer.MIN_VALUE;
        int width = arr[0].length - 2;

        for (int row = 0; row < arr.length - 2; row++) {
            for (int j = 0; j < width; j++) {

                maxValue = Math.max(
                        maxValue,
                        Arrays.stream(arr[row], j, j + 3).sum()
                                + arr[row + 1][j + 1]
                                + Arrays.stream(arr[row + 2], j, j + 3).sum());
            }
        }

        return maxValue;
    }

    // Approach 4: Use stream to loop/sum rather than for loops (SLOWEST)
    private static int solve4(int[][] arr) {

        int width = arr[0].length - 2;
        return IntStream.range(0, arr.length - 2).map(
                (row) -> IntStream.range(0, width).map(
                        col -> Arrays.stream(arr[row], col, col + 3).sum()
                                + arr[row + 1][col + 1]
                                + Arrays.stream(arr[row + 2], col, col + 3).sum()

                ).max().getAsInt()
        ).max().getAsInt();

    }

private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        int[][] arr = new int[6][6];
        List<Integer> values = new ArrayList<>();

        for (int i = 0; i < 6; i++) {
            String[] arrRowItems = scanner.nextLine().split(" ");
            scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

            for (int j = 0; j < 6; j++) {
                int arrItem = Integer.parseInt(arrRowItems[j]);
                arr[i][j] = arrItem;
								
                if(i - 2 >= 0 && j - 2 >= 0){
                int firstRow = (arr[i][j])+(arr[i][j-1])+(arr[i][j-2]);
                int secondRow = arr[i-1][j-1];
                int thirdRow = arr[i-2][j]+arr[i-2][j-1]+arr[i-2][j-2];
                    values.add(firstRow+secondRow+thirdRow);
                }
            }
        }
        System.out.println(Collections.max(values));
        scanner.close();
    }
}