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
  
  input = sys.stdin.buffer.readline
  
  H, W, K = map(int, input().split())
  x1, y1, x2, y2 = map(int, input().split())
  state = [list(input().rstrip()) for _ in range(H)]
  
  q = [(x1 - 1, y1 - 1)]
  checked = [[-1] * W for _ in range(H)]
  checked[x1 - 1][y1 - 1] = 0
  while q:
      qq = []
      for x, y in q:
          d = checked[x][y]
          dx = 1
          while x + dx < H and state[x + dx][y] == ord(".") and dx <= K:
              if checked[x + dx][y] == -1:
                  checked[x + dx][y] = d + 1
                  qq.append((x + dx, y))
              elif checked[x + dx][y] >= d + 1:
                  checked[x + dx][y] = d + 1
              else:
                  break
              dx += 1
          dx = -1
          while x + dx >= 0 and state[x + dx][y] == ord(".") and dx >= -K:
              if checked[x + dx][y] == -1:
                  checked[x + dx][y] = d + 1
                  qq.append((x + dx, y))
              elif checked[x + dx][y] >= d + 1:
                  checked[x + dx][y] = d + 1
              else:
                  break
              dx -= 1
          dy = 1
          while y + dy < W and state[x][y + dy] == ord(".") and dy <= K:
              if checked[x][y + dy] == -1:
                  checked[x][y + dy] = d + 1
                  qq.append((x, y + dy))
              elif checked[x][y + dy] >= d + 1:
                  checked[x][y + dy] = d + 1
              else:
                  break
              dy += 1
          dy = -1
          while y + dy >= 0 and state[x][y + dy] == ord(".") and dy >= -K:
              if checked[x][y + dy] == -1:
                  checked[x][y + dy] = d + 1
                  qq.append((x, y + dy))
              elif checked[x][y + dy] >= d + 1:
                  checked[x][y + dy] = d + 1
              else:
                  break
              dy -= 1
      q = qq
  
  print(checked[x2 - 1][y2 - 1])
  
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"}]