### BUGGY CODE ###

import heapq
from numba import jit

@jit
def main(h, w, k, x1, y1, x2, y2, pond):
    hq = [[0, (x1, y1)]]
    st = set()
    R = set()
    L = set()
    U = set()
    D = set()
    dic = {}
    dic[(x1, y1)] = 0
    ans = -1
    while len(hq) > 0:
        cost, p = heapq.heappop(hq)
        if p in st:
            continue
        else:
            st.add(p)
        x, y = p[0], p[1]
        if x == x2 and y == y2:
            ans = cost
            break
        c = cost + 1
        for i in range(1, k+1):
            np = (x-i, y)
            if np in D or np in st or pond[x-i][y] == 1:
                break
            if np in dic and dic[np] <= c:
                U.add(np)
                continue
            dic[np] = c
            heapq.heappush(hq, [c, (x-i, y)])
            U.add(np)
        for i in range(1, k+1):
            np = (x+i, y)
            if np in U or np in st or pond[x+i][y] == 1:
                break
            if np in dic and dic[np] <= c:
                D.add(np)
                continue
            dic[np] = c
            heapq.heappush(hq, [c, (x+i, y)])
            D.add(np)
        for i in range(1, k+1):
            np = (x, y-i)
            if np in R or np in st or pond[x][y-i] == 1:
                break
            if np in dic and dic[np] <= c:
                L.add(np)
                continue
            dic[np] = c
            heapq.heappush(hq, [c, (x, y-i)])
            L.add(np)
        for i in range(1, k+1):
            np = (x, y+i)
            if np in L or np in st or pond[x][y+i] == 1:
                break
            if np in dic and dic[np] <= c:
                R.add(np)
                continue
            dic[np] = c
            heapq.heappush(hq, [c, (x, y+i)])
            R.add(np)
    print(ans)

if __name__ == "__main__":
    h, w, k = map(int, input().split())
    x1, y1, x2, y2 = map(int, input().split())
    pond = [[1]*(w+2) for _ in range(h+2)]
    for i in range(1, h+1):
        s = input()
        for j in range(w):
            if s[j] == ".":
                pond[i][j+1] = 0
    main(h, w, k, x1, y1, x2, y2, pond)


### FIXED CODE ###

import queue
import sys
input = sys.stdin.readline

def calc_next_point(x, y, vec, dist):
    if vec == 0:
        return x-dist, y
    elif vec == 1:
        return x, y+dist
    elif vec == 2:
        return x+dist, y
    else:
        return x, y-dist

def main():
    h, w, k = map(int, input().split())
    x1, y1, x2, y2 = map(int, input().split())
    pond = [[[-1]*4 for j in range(w+2)] for i in range(h+2)]
    for i in range(1, h+1):
        s = input()
        for j in range(w):
            if s[j] == ".":
                for l in range(4):
                    pond[i][j+1][l] = float("inf")
    qs = [queue.Queue(), queue.Queue()]
    for i in range(4):
        pond[x1][y1][i] = 0
        qs[0].put([0, x1, y1, i])
    p = 0
    minans = float("inf")
    g = False
    while not qs[0].empty() or not qs[1].empty():
        while not qs[p].empty():
            cost, x, y, vec = qs[p].get()
            np = (p+1)%2
            if cost >= minans:
                g = True
                break
            if x == x2 and y == y2:
                if cost < minans:
                    minans = cost
                g = True
                break
            for i in range(1, k+1):
                nx, ny = calc_next_point(x, y, vec, i)
                if pond[nx][ny][vec] == -1:
                    break
                ncost = cost + 1
                if pond[nx][ny][vec] < ncost:
                    break
                if pond[nx][ny][vec] == ncost:
                    continue
                pond[nx][ny][vec] = ncost
                if nx == x2 and ny == y2:
                    if ncost < minans:
                        minans = ncost
                    g = True
                    break
                for j in range(4):
                    if i == k:
                        if j != (vec+2)%4:
                            if j == vec or pond[nx][ny][j] > ncost:
                                pond[nx][ny][j] = ncost
                                qs[np].put([ncost, nx, ny, j])
                    elif i == 1:
                        if j != vec:
                            if j == (vec+2)%4 or pond[nx][ny][j] > ncost:
                                pond[nx][ny][j] = ncost
                                qs[np].put([ncost, nx, ny, j])
                    else:
                        if j != vec and j != (vec+2)%4:
                            if pond[nx][ny][j] > ncost:
                                pond[nx][ny][j] = ncost
                                qs[np].put([ncost, nx, ny, j])
            if g:
                break
        if g:
            break
        p = (p+1)%2
    if min(pond[x2][y2]) == float("inf"):
        print(-1)
    else:
        print(min(pond[x2][y2]))

if __name__ == "__main__":
    main()