vector<string> cavityMap(vector<string> grid) {
    for(int i = 1; i < grid.size() - 1; i++){
        for(int j = 1; j < grid[i].size()-1; j++){
            if(grid[i][j] > grid[i][j-1] && grid[i][j] > grid[i][j+1])
                if(grid[i][j] > grid[i-1][j] && grid[i][j] > grid[i+1][j])
                grid[i][j] = 'X'; 
        }
    }
    return grid;
}

import java.util.*;

public class Solution {

    public  static char[][] convertArray(List<String> grid){
        int n = grid.size();
        char[][] arr = new char[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                char num = grid.get(i).charAt(j);
                arr[i][j]=num;
            }
        }
        return arr;
    }

    public static void cavityMap(List<String> grid) {
        char[][] arr = convertArray(grid);
        int n = arr.length;
        for(int i=1;i<n-1;i++){
            for(int j=1;j<n-1;j++){
                int target =  arr[i][j]-'0';
                int up =  arr[i-1][j]-'0';
                int down =  arr[i+1][j]-'0';
                int left =  arr[i][j-1]-'0';
                int right =  arr[i][j+1]-'0';
                if(up < target && down < target && left < target && right < target){
                    arr[i][j]='X';
                }
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        List<String> list = new ArrayList<String>();
        for(int i=0;i<n;i++){
            list.add(sc.next());
        }
        cavityMap(list);
        sc.close();
    }
}

def cavityMap(grid):
    # Write your code here
    
    cavity = grid.copy() # overwriting original grid would cause error
    
    for i in range(1, len(grid)-1): # iterate thru each row ignore first and last
        
        cur = grid[i]
        pre = grid[i-1]
        nex = grid[i+1]
        
        for j in range(1, len(cur)-1): # identify cell and its adjacencies
            
            cell = cur[j]
            left = cur[j-1]
            rght = cur[j+1]
            topp = pre[j]
            botm = nex[j]
            
            if cell > left and cell > rght and cell > topp and cell > botm:
                cavity[i] = cavity[i][:j] + 'X' + cavity[i][j+1:]
                
    return cavity

def cavityMap(n,grid):
    ans=[[0 for _ in range(n)] for _ in range(n)]
    for i in range(1,n-1):
        for j in range(1,n-1):
            mat=[int(grid[i][j+1]),int(grid[i-1][j]),int(grid[i+1][j]),int(grid[i][j-1])]
            if int(grid[i][j])>max(mat):
                ans[i][j]='X'
    for k in range(n):
        for l in range(n):
            if ans[k][l]=='X':
                pass
            else:
                ans[k][l]=grid[k][l]
    res=[]
    for row in ans:
        res.append(''.join(map(str,row)))
    return res