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: def I():
      return int(input())
  
  
  def MI():
      return map(int, input().split())
  
  
  def LI():
      return list(map(int, input().split()))
  
  
  def main():
      from collections import deque
  
      H, W, K = MI()
      x1, y1, x2, y2 = MI()
  
      C = []
      C.append(["@"] * (W + 2))
      for _ in range(H):
          c = ["@"] + list(input()) + ["@"]
          C.append(c)
      C.append(["@"] * (W + 2))
  
      # 各ますにつき4方向分のデータを持つ，コストは（移動回数，今直線で動いた数）でもつ，移動回数がより重要視される
      inf = 10**10
      D = [
          [[(inf, inf)] * 4 for _ in range(W + 2)] for _ in range(H + 2)
      ]  # 下上右左の4方向
      # D[i][j][k]はi行j列k向き
  
      dq = deque()
      for k in range(4):
          D[x1][y1][k] = (0, 0)
          dq.append((x1, y1, k, 0, 0))
  
      dx = [1, -1, 0, 0]
      dy = [0, 0, -1, 1]
  
      # 01BFSでいけそう
  
      while len(dq):
          x, y, d, cnt, k = dq.popleft()
  
          for nd in range(4):
              # 方向そのまま
              if nd == d:
                  nx = x + dx[nd]
                  ny = y + dy[nd]
                  nk = (k + 1) % K
                  ncnt = cnt
                  if k + 1 >= K:
                      ncnt += 1
              # 方向転換
              else:
                  nk = 0
                  ncnt = cnt
                  if k != 0:
                      ncnt += 1
                  nx = x
                  ny = y
              if C[nx][ny] == ".":
                  if D[nx][ny][nd] > (ncnt, nk):  # 更新する場合だけ
                      D[nx][ny][nd] = (ncnt, nk)
                      if ncnt == cnt:
                          dq.appendleft((nx, ny, nd, ncnt, nk))
                      else:
                          dq.append((nx, ny, nd, ncnt, nk))
  
      ans = inf
      for d in range(4):
          temp = D[x2][y2][d][0]
          if D[x2][y2][d][1]:
              temp += 1
          ans = min(ans, temp)
  
      if ans >= inf:
          ans = -1
      print(ans)
  
      # for i in range(1,H+1):
      #     for j in range(1,W+1):
      #         print(D[i][j])
  
  
  main()
  
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"}]