### BUGGY CODE ###

import heapq
import sys
input = sys.stdin.readline

def update(x, y, k, cost, pt, vec, pond, row, hq, fs):
    for i in range(1, k+1):
        nx, ny = x, y
        nc = cost+1
        if vec == 0:
            nx -= i
        elif vec == 1:
            ny += i
        elif vec == 2:
            nx += i
        else:
            ny -= i
        if pond[nx][ny] == 1:
            return
        if row[nx][ny][vec] > nc:
            row[nx][ny][vec] = nc
            if i == k:
                heapq.heappush(hq, [nc, nx, ny, i, vec])
            if fs[nx][ny]:
                for j in range(1, 4):
                    if row[nx][ny][(vec+j)%4] > nc:
                        row[nx][ny][(vec+j)%4] = nc
                        heapq.heappush(hq, [nc, nx, ny, k, (vec+j)%4])
                fs[nx][ny] = False
        else:
            return

def 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
    hq = []
    row = [[[float("inf")]*4 for j in range(w+2)] for i in range(h+2)]
    fs = [[True]*(w+2) for _ in range(h+2)]
    for i in range(4):
        row[x1][y1][i] = 0
        heapq.heappush(hq, [0, x1, y1, k, i])
    while len(hq) > 0:
        cost, x, y, pt, vec = heapq.heappop(hq)
        if cost > row[x][y][vec]:
            continue
        if pt == k:
            update(x, y, k, cost, pt, vec, pond, row, hq, fs)
    ans = min(row[x2][y2])
    if ans == float("inf"):
        print(-1)
    else:
        print(ans)

if __name__ == "__main__":
    main()


### 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()