import java.util.*;

public class Main {
    public static int[][] solve(int[][] matrix) {
        List<int[]> localMaximumList = new ArrayList<>();

        int m = matrix.length, n = matrix[0].length;
        for (int row = 0; row < m; row++) {
            for (int col = 0; col < n; col++) {
                // try to consider this as local maximum
                if (matrix[row][col] > 0) {
                    // this can be considered
                    int[][] ignoredCells = new int[][]{
                            {row - matrix[row][col], col - matrix[row][col]},
                            {row - matrix[row][col], col + matrix[row][col]},
                            {row + matrix[row][col], col - matrix[row][col]},
                            {row + matrix[row][col], col + matrix[row][col]},
                            {row, col}
                    };
                    boolean canBeLocalMaximum = true;
                    for (int regionRow = Math.max(row - matrix[row][col], 0); regionRow <= Math.min(row + matrix[row][col], m - 1); regionRow++) {
                        for (int regionCol = Math.max(col - matrix[row][col], 0); regionCol <= Math.min(col + matrix[row][col], n - 1); regionCol++) {
                            // ignore edge cases
                            boolean canIgnore = false;
                            for (int[] cell: ignoredCells) {
                                if (cell[0] == regionRow && cell[1] == regionCol) {
                                    canIgnore = true;
                                }
                            }
                            if (canIgnore) {
                                continue;
                            }

                            if (matrix[regionRow][regionCol] >= matrix[row][col]) {
                                canBeLocalMaximum = false;
                                break;
                            }
                        }
                        if (!canBeLocalMaximum) {
                            break;
                        }
                    }

                    if (canBeLocalMaximum) {
                        localMaximumList.add(new int[]{row, col});
                    }
                }
            }
        }

        int[][] result = new int[localMaximumList.size()][];
        for (int i = 0; i < localMaximumList.size(); i++) {
            result[i] = localMaximumList.get(i);
        }
        return result;
    }
    public static void main(String[] args) throws Exception {
        int[][] matrix = new int[][]{
                {3, 0, 0, 0, 0},
                {0, 0, 1, 0, 0},
                {0, 0, 2, 0, 0},
                {0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0},
                {0, 3, 0, 0, 3}
        };

        int[][] localMaximums = solve(matrix);
        for (int[] localMaximum: localMaximums) {
            System.out.println(localMaximum[0] + " " + localMaximum[1]);
        }
    }
}