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.

-----Constraints-----
 - 1 \leq H,W,K \leq 10^6
 - H \times W \leq 10^6
 - 1 \leq x_1,x_2 \leq H
 - 1 \leq y_1,y_2 \leq W
 - x_1 \neq x_2 or y_1 \neq y_2.
 - c_{i,j} is . or @.
 - c_{x_1,y_1} = .
 - c_{x_2,y_2} = .
 - All numbers in input are integers.

-----Input-----
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}

-----Output-----
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.

-----Sample Input-----
3 5 2
3 2 3 4
.....
.@..@
..@..

-----Sample Output-----
5

Initially, Snuke is at the square (3,2).
He can reach the square (3, 4) by making five strokes as follows:
 - From (3, 2), go west one square to (3, 1).
 - From (3, 1), go north two squares to (1, 1).
 - From (1, 1), go east two squares to (1, 3).
 - From (1, 3), go east one square to (1, 4).
 - From (1, 4), go south two squares to (3, 4).

Difficulty: MEDIUM_HARD

Solutions:
import sys
from collections import deque
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
input = lambda : sys.stdin.readline().rstrip()
YesNo = lambda b: bool([print('Yes')] if b else print('No'))
YESNO = lambda b: bool([print('YES')] if b else print('NO'))
int1 = lambda x: int(x) - 1
(H, W, K) = map(int, input().split())
(sy, sx, gy, gx) = map(int, input().split())
st = sx + sy * (W + 2)
gl = gx + gy * (W + 2)
c = ['@'] * (W + 2)
for i in range(H):
	c.extend(['@'] + list(input()) + ['@'])
c.extend(['@'] * (W + 2))
que = deque()
dist = [INF] * (W + 2) * (H + 2)
que.append(st)
dist[st] = 0
d = (-1, 1, W + 2, -(W + 2))
while que:
	v = que.popleft()
	for k in range(4):
		nv = v
		for _ in range(K):
			nv += +d[k]
			if c[nv] == '.' and dist[nv] > dist[v]:
				if dist[nv] == INF:
					dist[nv] = dist[v] + 1
					que.append(nv)
			else:
				break
print(dist[gl] if dist[gl] != INF else -1)


from heapq import heappop, heappush
from collections import deque

def dijkstra(xs, ys, xg, yg, h, w, k, field):
	inf = 1e+18
	dist = [[inf] * w for _ in range(h)]
	dist[xs][ys] = 0
	que = deque([(0, xs, ys)])
	dx = [-1, 0, 1, 0]
	dy = [0, 1, 0, -1]
	while que:
		(cost, x, y) = que.popleft()
		if cost > dist[x][y]:
			continue
		for v in range(4):
			(nx, ny) = (x, y)
			for _ in range(k):
				nx += dx[v]
				ny += dy[v]
				if not field[nx][ny]:
					break
				if dist[nx][ny] <= dist[x][y]:
					break
				if dist[nx][ny] > dist[x][y] + 1:
					dist[nx][ny] = dist[x][y] + 1
					que.append((dist[nx][ny], nx, ny))
	if dist[xg][yg] == inf:
		print(-1)
	else:
		print(dist[xg][yg])

def main():
	import sys

	def input():
		return sys.stdin.readline().rstrip()
	(h, w, k) = map(int, input().split())
	(xs, ys, xg, yg) = map(int, input().split())
	field = [[False] * (w + 2) for _ in range(h + 2)]
	for i in range(h):
		s = [True if _ == '.' else False for _ in input()]
		field[i + 1] = [False] + s + [False]
	h += 2
	w += 2
	dijkstra(xs, ys, xg, yg, h, w, k, field)

def __starting_point():
	main()
__starting_point()