Olya loves energy drinks. She loves them so much that her room is full of empty cans from energy drinks.

Formally, her room can be represented as a field of *n* × *m* cells, each cell of which is empty or littered with cans.

Olya drank a lot of energy drink, so now she can run *k* meters per second. Each second she chooses one of the four directions (up, down, left or right) and runs from 1 to *k* meters in this direction. Of course, she can only run through empty cells.

Now Olya needs to get from cell (*x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>) to cell (*x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub>). How many seconds will it take her if she moves optimally?

It's guaranteed that cells (*x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>) and (*x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub>) are empty. These cells can coincide.
The first line contains three integers *n*, *m* and *k* (1 ≤ *n*, *m*, *k* ≤ 1000) — the sizes of the room and Olya's speed.

Then *n* lines follow containing *m* characters each, the *i*-th of them contains on *j*-th position "#", if the cell (*i*, *j*) is littered with cans, and "." otherwise.

The last line contains four integers *x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>, *x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub> (1 ≤ *x*<sub class="lower-index">1</sub>, *x*<sub class="lower-index">2</sub> ≤ *n*, 1 ≤ *y*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">2</sub> ≤ *m*) — the coordinates of the first and the last cells.
In the first sample Olya should run 3 meters to the right in the first second, 2 meters down in the second second and 3 meters to the left in the third second.

In second sample Olya should run to the right for 3 seconds, then down for 2 seconds and then to the left for 3 seconds.

Olya does not recommend drinking energy drinks and generally believes that this is bad.
3 4 4
....
###.
....
1 1 3 1
3
3 4 1
....
###.
....
1 1 3 1
8
2 2 1
.#
#.
1 1 2 2
-1
10 10 1
##########
#.........
#.#######.
#.#.....#.
#.#.###.#.
#.#.#.#.#.
#.#.#.#.#.
#.#.#...#.
#.#.#####.
#.#.......
6 6 10 2
48
10 10 3
##########
##########
##########
##########
##########
##########
##########
#########.
#########.
####..###.
10 6 10 5
1
10 10 3
...##..#..
#.#..#...#
..#.##.#..
##..#..#.#
..#...##..
.#.#.#....
#......#..
.#.####.##
......#...
.#.##...##
4 6 8 1
7
10 10 1000
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
7 6 1 3
2
10 10 1000
..........
..........
..........
..........
..........
..........
..........
..........
..........
.....#....
3 9 5 1
2
10 10 10
...#......
##.#.#####
...#...###
.#####.###
...#...###
##.#.#####
...#...###
.#####.###
.......###
##########
1 1 1 10
17
2 5 5
#####
##.##
2 3 2 3
0
4 4 4
...#
.#.#
....
##..
1 1 3 4
2
6 6 100
....##
.##.##
.##.##
......
###.##
###.##
1 1 4 6
2
import sys
from collections import deque
input=sys.stdin.readline
n,m,k=map(int,input().split())
grid=[]
grid1=[]
grid2=[]
leftyes=[]
rightyes=[]
upyes=[]
downyes=[]
for i in range(n):
  grid.append(input())
  grid1.append([-1]*m)
  grid2.append([0]*m)
  leftyes.append([0]*m)
  rightyes.append([0]*m)
  downyes.append([0]*m)
  upyes.append([0]*m)
for i in range(n):
  count=0
  for j in range(m):
    if grid[i][j]=='.':
      count+=1
    else:
      count=0
    if count>k:
      leftyes[i][j]=1
      rightyes[i][j-k]=1
for i in range(m):
  count=0
  for j in range(n):
    if grid[j][i]=='.':
      count+=1
    else:
      count=0
    if count>k:
      upyes[j][i]=1
      downyes[j-k][i]=1
x1,y1,x2,y2=map(int,input().split())
que=deque([(x1-1,y1-1,0)])
grid1[x1-1][y1-1]=0
while que:
  x,y,step=que.popleft()
  if grid2[x][y]:
    continue
  grid2[x][y]=1
  if not(x<n-1 and grid1[x+1][y]!=-1):
    curr=x-1
    count=0
    while count<k and curr>=0 and grid[curr][y]=='.' and grid1[curr][y]==-1:
      que.append((curr,y,step+1))
      grid1[curr][y]=step+1
      curr-=1
      count+=1
  else:
    if upyes[x][y]:
      que.append((x-k,y,step+1))
      grid1[x-k][y]=step+1
  if not(x>0 and grid1[x-1][y]!=-1):
    curr=x+1
    count=0
    while count<k and curr<=n-1 and grid[curr][y]=='.' and grid1[curr][y]==-1:
      que.append((curr,y,step+1))
      grid1[curr][y]=step+1
      curr+=1
      count+=1
  else:
    if downyes[x][y]:
      que.append((x+k,y,step+1))
      grid1[x+k][y]=step+1
  if not(y<m-1 and grid1[x][y+1]!=-1):
    curr=y-1
    count=0
    while count<k and curr>=0 and grid[x][curr]=='.' and grid1[x][curr]==-1:
      que.append((x,curr,step+1))
      grid1[x][curr]=step+1
      curr-=1
      count+=1
  else:
    if leftyes[x][y]:
      que.append((x,y-k,step+1))
      grid1[x][y-k]=step+1
  if not(y>0 and grid1[x][y-1]!=-1):
    curr=y+1
    count=0
    while count<k and curr<=m-1 and grid[x][curr]=='.' and grid1[x][curr]==-1:
      que.append((x,curr,step+1))
      grid1[x][curr]=step+1
      curr+=1
      count+=1
  else:
    if rightyes[x][y]:
      que.append((x,y+k,step+1))
      grid1[x][y+k]=step+1
print(grid1[x2-1][y2-1])