import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) throws IOException {
        List<String> input = new ArrayList<>();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String temp;

        while ((temp = br.readLine()) != null && !temp.isEmpty()) {
            input.add(temp);
        }
        String answer = new Main().solution(input.toArray(new String[input.size()]));

        System.out.println(answer);
    }

    public String solution(String[] input) {

        int size = Integer.parseInt(input[0]);
        int[][] map = new int[size][size];

        for (int i = 0; i < size; i++) {
            String[] temp = input[i + 1].split(" ");
            for (int j = 0; j < temp.length; j++) {
                map[i][j] = Integer.parseInt(temp[j]);
            }
        }

        int maxNumber = moveTile(map,"", 0);


        return Integer.toString(maxNumber);
    }

    private int moveTile(int[][] map, String direction, int depth) {
        int maxNumber = 0;

        if(!direction.equals("")) {
            depth++;
            int[][] lockMap = new int[map.length][map[0].length];
            switch (direction) {
                case "up":
                    for (int i = 1; i < map.length; i++) {
                        for (int j = 0; j < map[i].length; j++) {
                            //checkMerge
                            for (int k = i-1; k >= 0; k--) {
                                if(map[k][j] == map[i][j] && lockMap[k][j] != -1) {
                                    map[k][j] += map[i][j];
                                    map[i][j] = 0;

                                    while (k - 1 >= 0 && map[k - 1][j] == 0) {
                                        map[k - 1][j] = map[k][j];
                                        map[k][j] = 0;
                                        k--;
                                    }

                                    lockMap[k][j] = -1;
                                    break;
                                }
                            }

                            //move
                            for (int k = i-1; k >= 0; k--) {
                                if(map[k][j] != 0){
                                    break;
                                }
                                map[k][j] = map[k+1][j];
                                map[k+1][j] = 0;
                                k--;
                            }
                        }
                    }
                    break;
                case "down":
                    for (int i = map.length - 2; i >= 0; i--) {
                        for (int j = 0; j < map[i].length; j++) {
                            //checkMerge
                            for (int k = i+1; k < map.length; k++) {
                                if(map[k][j] == map[i][j] && lockMap[k][j] != -1) {
                                    map[k][j] += map[i][j];
                                    map[i][j] = 0;

                                    while (k + 1 < map.length && map[k + 1][j] == 0) {
                                        map[k + 1][j] = map[k][j];
                                        map[k][j] = 0;
                                        k++;
                                    }

                                    lockMap[k][j] = -1;
                                    break;
                                }
                            }

                            //move
                            for (int k = i+1; k < map.length; k++) {
                                if(map[k][j] != 0){
                                    break;
                                }
                                map[k][j] = map[k-1][j];
                                map[k-1][j] = 0;
                                k++;
                            }
                        }
                    }
                    break;
                case "left":
                    for (int j = 1; j < map[0].length; j++) {
                        for (int i = 0; i < map.length; i++) {
                            //checkMerge
                            for (int k = j-1; k >= 0; k--) {
                                if(map[i][k] == map[i][j] && lockMap[i][k] != -1) {
                                    map[i][k] += map[i][j];
                                    map[i][j] = 0;

                                    while (k - 1 >= 0 && map[i][k - 1] == 0) {
                                        map[i][k - 1] = map[i][k];
                                        map[i][k] = 0;
                                        k--;
                                    }

                                    lockMap[i][k] = -1;
                                    break;
                                }
                            }

                            //move
                            for (int k = i-1; k >= 0; k--) {
                                if(map[i][k] != 0){
                                    break;
                                }
                                map[i][k] = map[i][k+1];
                                map[i][k+1] = 0;
                                k--;
                            }
                        }
                    }
                    break;
                case "right":
                    for (int j = map[0].length - 2; j >= 0; j--) {
                        for (int i = 0; i < map.length; i++) {
                            //checkMerge
                            for (int k = j+1; k < map.length; k++) {
                                if(map[i][k] == map[i][j] && lockMap[i][k] != -1) {
                                    map[i][k] += map[i][j];
                                    map[i][j] = 0;

                                    while (k + 1 < map.length && map[i][k + 1] == 0) {
                                        map[i][k + 1] = map[i][k];
                                        map[i][k] = 0;
                                        k++;
                                    }

                                    lockMap[i][k] = -1;
                                    break;
                                }
                            }

                            //move
                            for (int k = i+1; k < map.length; k++) {
                                if(map[i][k] != 0){
                                    break;
                                }
                                map[i][k] = map[i][k-1];
                                map[i][k-1] = 0;
                                k++;
                            }
                        }
                    }
                    break;
            }

            if(depth >= 5) {
                for (int i = 0; i < map.length; i++) {
                    for (int j = 0; j < map[i].length; j++) {
                        if(map[i][j] > maxNumber) {
                            maxNumber = map[i][j];
                        }
                    }
                }
                return maxNumber;
            }
        }

        int up = moveTile(map, "up", depth);
        int down = moveTile(map, "down", depth);
        int left = moveTile(map, "left", depth);
        int right = moveTile(map, "right", depth);

        if(maxNumber < up) {
            maxNumber = up;
        }
        if(maxNumber < down) {
            maxNumber = down;
        }
        if(maxNumber < left) {
            maxNumber = left;
        }
        if(maxNumber < right) {
            maxNumber = right;
        }

        return maxNumber;
    }
}
