struct steps {
  int x, y, movements;
};

int validPosition(int n, int x, int y) {

  if (x < 0 || x >= n || y < 0 || y >= n)
    return 0;
  return 1;
}

int minimumMoves(int grid_count, char **grid, int startX, int startY, int goalX,
                 int goalY) {
  int ans = 0;
  int MAX_SIZE = (grid_count * grid_count) + 2;
  struct steps *queue = malloc(MAX_SIZE * sizeof(struct steps));
  int back = 0, front = 0;

  struct steps root = {startX, startY, 0};
  queue[back++] = root;
  grid[startX][startY] = 'X';
  //  printf("front = %d  back = %d\n", front, back);
  while (front < back && back < MAX_SIZE) {
    root = queue[front++];
    if (root.x == goalX && root.y == goalY) {
      free(queue);
      return root.movements;
    }

    int vx[] = {-1, 0, 1, 0};
    int vy[] = {0, 1, 0, -1};
    for (int c = 0; c < 4; c++) {
      struct steps child = root;
      while (validPosition(grid_count, child.x + vx[c], child.y + vy[c]) &&
             grid[child.x + vx[c]][child.y + vy[c]] == '.') {
        child.x += vx[c];
        child.y += vy[c];
        child.movements = root.movements + 1;
        grid[child.x][child.y] = 'X';
        queue[back++] = child;
      }
    }
  }
  free(queue);
  return -1;
}

from collections import deque

def minimumMoves(grid, startX, startY, goalX, goalY):
    n = len(grid)
    m = len(grid[0])
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]    
    queue = deque([(startX, startY, 0)])  
    visited = set()
    visited.add((startX, startY))
    while queue:
        x, y, moves = queue.popleft()        
        if (x, y) == (goalX, goalY):
            return moves        
        for dx, dy in directions:
            nx, ny = x, y
            while 0 <= nx + dx < n and 0 <= ny + dy < m and grid[nx + dx][ny + dy] != 'X':
                nx += dx
                ny += dy
                if (nx, ny) not in visited:
                    visited.add((nx, ny))
                    queue.append((nx, ny, moves + 1))    
    return -1

void update(int I, int J, int i, int j, vector<vector<bool>>& visited, vector<vector<int>>& minPath, queue<pair<int, int>>& Q) {
    if (visited[i][j]) return;
    visited[i][j] = true;
    minPath[i][j] = minPath[I][J] + 1;
    Q.push(make_pair(i, j));
    return;
}

int minimumMoves(int n, vector<vector<char>> grid, int startX, int startY, int goalX, int goalY) {
    vector<vector<bool>> visited(n + 2, vector<bool>(n + 2));
    vector<vector<int>> minPath(n + 2, vector<int>(n + 2, -1));
    queue<pair<int, int>> Q;
    Q.push(make_pair(startX, startY));
    visited[startX][startY] = true;
    minPath[startX][startY] = 0;
    while (!Q.empty()) {
        int I = Q.front().first, J = Q.front().second;
        for (int i=1; I - i > 0; i++) {
            if (grid[I-i][J] == 'X') break;
            update(I, J, I-i, J, visited, minPath, Q);
        }
        for (int i=1; I + i < n+1; i++) {
            if (grid[I+i][J] == 'X') break;
            update(I, J, I+i, J, visited, minPath, Q);
        }
        for (int j=1; J - j > 0; j++) {
            if (grid[I][J-j] == 'X') break;
            update(I, J, I, J-j, visited, minPath, Q);
        }
        for (int j=1; J + j < n+1; j++) {
            if (grid[I][J+j] == 'X') break;
            update(I, J, I, J+j, visited, minPath, Q);
        }
        Q.pop();
    }
    return minPath[goalX][goalY];
}

int main()
{
    int n, startX, startY, goalX, goalY;
    string s;
    cin >> n;
    vector<vector<char>> grid(n + 2, vector<char>(n + 2));
    for (int i = 1; i <= n; i++) {
        cin >> s;
        for (int j = 1; j <= n; j++) grid[i][j] = s[j - 1];
    }
    cin >> startX >> startY >> goalX >> goalY;
    cout << minimumMoves(n, grid, startX + 1, startY + 1, goalX + 1, goalY + 1);
}