output_description: Print the minimum number of strokes Snuke takes to travel from the square
  (x_1,y_1) to (x_2,y_2), or print `-1` if the travel is impossible.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W K
      x_1 y_1 x_2 y_2
      c_{1,1}c_{1,2} .. c_{1,W}
      c_{2,1}c_{2,2} .. c_{2,W}
      :
      c_{H,1}c_{H,2} .. c_{H,W}
attempt: import sys
  import numpy as np
  from numba import njit
  from heapq import heappop, heappush
  
  read = sys.stdin.buffer.read
  readline = sys.stdin.buffer.readline
  readlines = sys.stdin.buffer.readlines
  
  
  @njit("(b1[:],i8,i8,i8,i8,i8)", cache=True)
  def main(C, H, W, S, T, K):
      INF = 10**18
      N = H * W
      q = [5 * S]
      dist = np.full((5 * N), INF, np.int64)
      dist[5 * S] = 0
      move = [0, 1, -1, W, -W]
      B = 5 * N + 10
      while q:
          x = heappop(q)
          dist_x, x = divmod(x, B)
          if dist_x > dist[x]:
              continue
          v, d = divmod(x, 5)
          if d == 0:
              # どちらかに進む
              for i in range(1, 5):
                  w = v + move[i]
                  y = 5 * w + i
                  dist_y = dist_x + 1
                  if C[w] and dist_y < dist[y]:
                      dist[y] = dist_y
                      heappush(q, B * dist_y + y)
          else:
              # 直進する
              if dist_x % K != 0:
                  w = v + move[d]
                  y = 5 * w + d
                  dist_y = dist_x + 1
                  if C[w] and dist_y < dist[y]:
                      dist[y] = dist_y
                      heappush(q, B * dist_y + y)
              # 止まって向きを変える権利を得る
              y = 5 * v
              dist_y = dist_x + (-dist_x) % K
              if dist_y < dist[y]:
                  dist[y] = dist_y
                  heappush(q, B * dist_y + y)
      x = dist[5 * T]
      if x == INF:
          return -1
      return dist[5 * T] // K
  
  
  H, W, K = map(int, readline().split())
  x1, y1, x2, y2 = map(int, readline().split())
  
  C = np.zeros((H + 2, W + 2), np.bool_)
  C[1:-1, 1:-1] = np.frombuffer(read(), "S1").reshape(H, -1)[:, :W] == b"."
  C = C.ravel()
  H += 2
  W += 2
  
  S = W * x1 + y1
  T = W * x2 + y2
  
  print(main(C, H, W, S, T, K))
  
problem_description: Statement
  
  Snuke, a water strider, lives in a rectangular pond that can be seen as a grid
  with H east-west rows and W north-south columns. Let (i,j) be the square at
  the i-th row from the north and j-th column from the west.
  
  Some of the squares have a lotus leaf on it and cannot be entered. The square
  (i,j) has a lotus leaf on it if c_{ij} is `@`, and it does not if c_{ij} is
  `.`.
  
  In one stroke, Snuke can move between 1 and K squares (inclusive) toward one
  of the four directions: north, east, south, and west. The move may not pass
  through a square with a lotus leaf. Moving to such a square or out of the pond
  is also forbidden.
  
  Find the minimum number of strokes Snuke takes to travel from the square
  (x_1,y_1) to (x_2,y_2). If the travel from (x_1,y_1) to (x_2,y_2) is
  impossible, point out that fact.
samples: [{"input": "3 5 2\n    3 2 3 4\n    .....\n    .@..@\n    ..@..", "output": "5\n    \n\nInitially, Snuke is at the square (3,2). He can reach the square (3, 4) by\nmaking five strokes as follows:\n\n  * From (3, 2), go west one square to (3, 1).\n\n  * From (3, 1), go north two squares to (1, 1).\n\n  * From (1, 1), go east two squares to (1, 3).\n\n  * From (1, 3), go east one square to (1, 4).\n\n  * From (1, 4), go south two squares to (3, 4).\n\n* * *"}, {"input": "1 6 4\n    1 1 1 6\n    ......", "output": "2\n    \n\n* * *"}, {"input": "3 3 1\n    2 1 2 3\n    .@.\n    .@.\n    .@.", "output": "-1"}]