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
from collections import deque
import sys

input = sys.stdin.readline

n,m,k = map(int,input().split())
B = [list(input().strip()) for _ in range(n)]

x1,y1,x2,y2 = map(int,input().split())

x1 -= 1
y1 -= 1
x2 -= 1
y2 -= 1

right = [[-1]*m for _ in range(n)]
left = [[-1]*m for _ in range(n)]
up = [[-1]*m for _ in range(n)]
down = [[-1]*m for _ in range(n)]

for i in range(n):
    j0 = 0
    for j in range(m):
        if B[i][j] == "#":
            continue

        if j0<j: j0 = j
        while j0+1 < m and j0+1-j <= k and B[i][j0 + 1] == ".":
            j0 += 1

        right[i][j] = j0
    
    j0 = m-1
    for j in range(m-1,-1,-1):
        if B[i][j] == "#":
            continue

        if j<j0: j0 = j
        while j0>=1 and j-j0+1 <= k and B[i][j0 - 1] == ".":
            j0 -= 1

        left[i][j] = j0

for j in range(m):
    i0 = 0
    for i in range(n):
        if B[i][j] == "#":
            continue

        if i0<i: i0 = i
        while i0+1 < n and i0+1-i <= k and B[i0 + 1][j] == ".":
            i0 += 1

        down[i][j] = i0

    i0 = n-1
    for i in range(n):
        if B[i][j] == "#":
            continue

        if i<i0: i0 = i
        while i0>=1 and i-i0+1 <= k and B[i0 - 1][j] == ".":
            i0 -= 1

        up[i][j] = i0

inf = float('inf')
d = [[inf]*m for _ in range(n)]
d[x1][y1] = 0

q = deque()
q.append((x1,y1))

while q:
    x,y = q.popleft()

    # left
    y0 = left[x][y]
    while d[x][y0] == inf:
        d[x][y0] = 1 + d[x][y]
        q.append((x,y0))
        y0 += 1
    
    # right
    y0 = right[x][y]
    while d[x][y0] == inf:
        d[x][y0] = 1 + d[x][y]
        q.append((x,y0))
        y0 -= 1

    # up
    x0 = up[x][y]
    while d[x0][y] == inf:
        d[x0][y] = 1 + d[x][y]
        q.append((x0,y))
        x0 += 1

    # down
    x0 = down[x][y]
    while d[x0][y] == inf:
        d[x0][y] = 1 + d[x][y]
        q.append((x0,y))
        x0 -= 1


if d[x2][y2] != inf:
    print(d[x2][y2])
else:
    print(-1)
