class Node:
    def __init__(self, idx):
        self.idx = idx
        self.reacheables = []
    
    def connect(self, node):
        self.reacheables.append(node)
        
class Graph:
    def __init__(self):
        self.nodes = {}
    
    def connect(self, node1_id, node2_id):
        if node1_id in self.nodes:
            node1 = self.nodes[node1_id]
        else:
            node1 = Node(node1_id)
        
        if node2_id in self.nodes:
            node2 = self.nodes[node2_id]
        else:
            node2 = Node(node2_id)
        
        node1.connect(node2)
        node2.connect(node1)
        self.nodes[node1_id] = node1
        self.nodes[node2_id] = node2
        
    def find_distance(self, s, val):
        levels = {s: 0}
        frontier = [s]
        j = 1
        while frontier:
            next_node = []
            for node in frontier:
                childs = node.reacheables
                for child in childs:
                    if child.idx not in levels:
                        if child.idx == val:
                            return j
                        levels[child.idx] = j
                        next_node.append(child)
            j += 1
            frontier = next_node
        return "Problem, seems not reached"

def minimumMoves(grid, startX, startY, goalX, goalY):
    
    g = Graph()
    l = len(grid)
    # CREATE THE GRAPH:
    for i in range(l):
        for j in range(l):
            if grid[i][j] != 'X':
                cell_id = (i, j)
                if cell_id in g.nodes:
                    node_cell = g.nodes[cell_id]
                else:
                    node_cell = Node(cell_id)
                    g.nodes[cell_id] = node_cell
                if i < l - 1:
                    r_neighb = i+1
                    while r_neighb < l and grid[r_neighb][j] != 'X':
                        g.connect(cell_id, (r_neighb, j))
                        r_neighb += 1
                if j < l - 1:
                    l_neighb = j+1
                    while l_neighb < l and grid[i][l_neighb] != 'X':
                        g.connect(cell_id, (i, l_neighb))
                        l_neighb += 1
    start_node = g.nodes[(startX, startY)]
    sol = g.find_distance(start_node, (goalX, goalY))
    return sol