output_description: Print the minimum number of times the magician needs to use the magic. If he
  cannot reach (D_h,D_w), print `-1` instead.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W
      C_h C_w
      D_h D_w
      S_{11}\ldots S_{1W}
      \vdots
      S_{H1}\ldots S_{HW}
attempt: # by the authority of GOD    author: manhar singh sachdev #
  
  import os, sys
  from io import BytesIO, IOBase
  from collections import deque, defaultdict
  
  
  def main():
      h, w = map(int, input().split())
      x1, y1 = map(int, input().split())
      a1, b1 = map(int, input().split())
      arr = [list(input().strip()) for _ in range(h)]
      dp = [[0] * w for _ in range(h)]
      se = set()
      for i in range(h):
          for j in range(w):
              if arr[i][j] != "#":
                  se.add((i, j))
      reg = 1
      while len(se):
          x = se.pop()
          curr = deque([x])
          while len(curr):
              y = curr.popleft()
              z = (y[0] + 1, y[1])
              dp[y[0]][y[1]] = reg
              if z[0] < h and z[1] < w and z in se and arr[z[0]][z[1]] != "#":
                  curr.append(z)
                  se.remove(z)
                  dp[z[0]][z[1]] = reg
              z = (y[0], y[1] + 1)
              if z[0] < h and z[1] < w and z in se and arr[z[0]][z[1]] != "#":
                  curr.append(z)
                  se.remove(z)
                  dp[z[0]][z[1]] = reg
              z = (y[0] - 1, y[1])
              if z[0] >= 0 and z[1] >= 0 and z in se and arr[z[0]][z[1]] != "#":
                  curr.append(z)
                  se.remove(z)
                  dp[z[0]][z[1]] = reg
              z = (y[0], y[1] - 1)
              if z[0] >= 0 and z[1] >= 0 and z in se and arr[z[0]][z[1]] != "#":
                  curr.append(z)
                  se.remove(z)
                  dp[z[0]][z[1]] = reg
          reg += 1
      path = defaultdict(set)
      for i in range(h):
          for j in range(w):
              if arr[i][j] == "#":
                  continue
              for r in range(-2, 3):
                  for q in range(-2, 3):
                      if (
                          0 <= i + r < h
                          and 0 <= j + q < w
                          and dp[i][j] != dp[i + r][j + q]
                          and dp[i + r][j + q]
                      ):
                          path[dp[i][j]].add(dp[i + r][j + q])
      st = dp[x1 - 1][y1 - 1]
      en = dp[a1 - 1][b1 - 1]
      curr = deque([st])
      visi = {st}
      ans = fl = 0
      val = 1
      tar = 0
      val1 = 0
      while len(curr):
          x = curr.popleft()
          tar += 1
          if x == en:
              fl = 1
              break
          for i in path[x]:
              if i not in visi:
                  visi.add(i)
                  curr.append(i)
                  val1 += 1
          if tar == val:
              tar = 0
              val = val1
              val1 = 0
              ans += 1
      if fl:
          print(ans)
      else:
          print(-1)
  
  
  # Fast IO Region
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  A maze is composed of a grid of H \times W squares - H vertical, W horizontal.
  
  The square at the i-th row from the top and the j-th column from the left -
  (i,j) \- is a wall if S_{ij} is `#` and a road if S_{ij} is `.`.
  
  There is a magician in (C_h,C_w). He can do the following two kinds of moves:
  
    * Move A: Walk to a road square that is vertically or horizontally adjacent to the square he is currently in.
    * Move B: Use magic to warp himself to a road square in the 5\times 5 area centered at the square he is currently in.
  
  In either case, he cannot go out of the maze.
  
  At least how many times does he need to use the magic to reach (D_h, D_w)?
samples: [{"input": "4 4\n    1 1\n    4 4\n    ..#.\n    ..#.\n    .#..\n    .#..", "output": "1\n    \n\nFor example, by walking to (2,2) and then using the magic to travel to (4,4),\njust one use of magic is enough.\n\nNote that he cannot walk diagonally.\n\n* * *"}, {"input": "4 4\n    1 4\n    4 1\n    .##.\n    ####\n    ####\n    .##.", "output": "-1\n    \n\nHe cannot move from there.\n\n* * *"}, {"input": "4 4\n    2 2\n    3 3\n    ....\n    ....\n    ....\n    ....", "output": "0\n    \n\nNo use of magic is needed.\n\n* * *"}, {"input": "4 5\n    1 2\n    2 5\n    #.###\n    ####.\n    #..##\n    #..##", "output": "2"}]