//Author: Pakhomovee 
#include <iostream> 
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <chrono>
#include <deque>
#include <assert.h>

using namespace std;
using namespace std::chrono;

void solve()
{
	auto start = system_clock::now();
	int h, w, k;
	cin >> h >> w >> k;
	int x1, y1, x2, y2;
	cin >> x1 >> y1 >> x2 >> y2;
	vector<vector<bool>> matr(h, vector<bool>(w, true));
	for (int i = 0; i < h; ++i)
	{
		for (int j = 0; j < w; ++j)
		{
			char x;
			cin >> x;
			if (x == '@')
			{
				matr[i][j] = false;
			}
		}
	}

		deque<pair<int, int>> q1;
	vector<vector<int>> dist1(h, vector<int>(w, 1e9));
	dist1[x1 - 1][y1 - 1] = 0;
	q1.push_back({ x1 - 1, y1 - 1 });
	while (!q1.empty())
	{
		auto end = system_clock::now();
		if (duration_cast<milliseconds> (end - start).count() > 2000)
		{
			break;
		}
		pair<int, int> x = q1.front();
		q1.pop_front();
		for (int i = 1; i <= 1; ++i)
		{
			if (x.first - i >= 0 && matr[x.first - i][x.second])
			{
				if (dist1[x.first - i][x.second] > dist1[x.first][x.second] + 1)
				{
					dist1[x.first - i][x.second] = dist1[x.first][x.second] + 1;
					q1.push_back({ x.first - i, x.second });
				}
			}
			if (x.second - i >= 0 && matr[x.first][x.second - i])
			{
				if (dist1[x.first][x.second - i] > dist1[x.first][x.second] + 1)
				{
					dist1[x.first][x.second - i] = dist1[x.first][x.second] + 1;
					q1.push_back({ x.first, x.second - i });
				}
			}
			if (x.first + i < h && matr[x.first + i][x.second])
			{
				if (dist1[x.first + i][x.second] > dist1[x.first][x.second] + 1)
				{
					dist1[x.first + i][x.second] = dist1[x.first][x.second] + 1;
					q1.push_back({ x.first + i, x.second });
				}
			}
			if (x.second + i < w && matr[x.first][x.second + i])
			{
				if (dist1[x.first][x.second + i] > dist1[x.first][x.second] + 1)
				{
					dist1[x.first][x.second + i] = dist1[x.first][x.second] + 1;
					q1.push_back({ x.first, x.second + i });
				}
			}
		}
	}
 
	if (dist1[x2 - 1][y2 - 1] == 1e9)
	{
		cout << -1;
		return;
	}
 
	deque<pair<int, int>> q;
	vector<vector<int>> dist(h, vector<int>(w, 1e9));
	dist[x1 - 1][y1 - 1] = 0;
	q.push_back({ x1 - 1, y1 - 1 });
	while(!q.empty())
	{
		auto end = system_clock::now();
		if (duration_cast<milliseconds> (end - start).count() > 2000)
		{
			break;
		}
		pair<int, int> x = q.front();
		if (x.first == x2 - 1 && x.second == y2 - 1)
		{
			cout << dist[x2 - 1][y2 - 1];
			return;
		}
		q.pop_front();
		vector<bool> ok(4, true);
		for (int i = 1; i <= k; ++i)
		{
			if (x.first - i >= 0 && ok[0])
			{
				if (!matr[x.first - i][x.second])
				{
					ok[0] = false;
				}
				else if (dist[x.first - i][x.second] > dist[x.first][x.second] + 1)
				{
					dist[x.first - i][x.second] = dist[x.first][x.second] + 1;
					q.push_back({ x.first - i, x.second });
				}
			}
			if (x.second - i >= 0 && ok[1])
			{
				if (!matr[x.first][x.second - i])
				{
					ok[1] = false;
				}
				else if (dist[x.first][x.second - i] > dist[x.first][x.second] + 1)
				{
					dist[x.first][x.second - i] = dist[x.first][x.second] + 1;
					q.push_back({ x.first, x.second - i});
				}
			}
			if (x.first + i < h && ok[2])
			{
				if (!matr[x.first + i][x.second])
				{
					ok[2] = false;
				}
				else if (dist[x.first + i][x.second] > dist[x.first][x.second] + 1)
				{
					dist[x.first + i][x.second] = dist[x.first][x.second] + 1;
					q.push_back({ x.first + i, x.second });
				}
			}
			if (x.second + i < w && ok[3])
			{
				if (!matr[x.first][x.second + i])
				{
					ok[3] = false;
				}
				else if (dist[x.first][x.second + i] > dist[x.first][x.second] + 1)
				{
					dist[x.first][x.second + i] = dist[x.first][x.second] + 1;
					q.push_back({ x.first, x.second + i });
				}
			}
		}
	}
	if (true)
	{
		deque<pair<int, int>> q1;
		vector<vector<int>> dist1(h, vector<int>(w, 1e9));
		dist1[x1 - 1][y1 - 1] = 0;
		q1.push_back({ x1 - 1, y1 - 1 });
		while (!q1.empty())
		{
			pair<int, int> x = q1.front();
			q1.pop_front();
			for (int i = 1; i <= 1; ++i)
			{
				if (x.first - i >= 0 && matr[x.first - i][x.second])
				{
					if (dist1[x.first - i][x.second] > dist1[x.first][x.second] + 1)
					{
						dist1[x.first - i][x.second] = dist1[x.first][x.second] + 1;
						q1.push_back({ x.first - i, x.second });
					}
				}
				if (x.second - i >= 0 && matr[x.first][x.second - i])
				{
					if (dist1[x.first][x.second - i] > dist1[x.first][x.second] + 1)
					{
						dist1[x.first][x.second - i] = dist1[x.first][x.second] + 1;
						q1.push_back({ x.first, x.second - i });
					}
				}
				if (x.first + i < h && matr[x.first + i][x.second])
				{
					if (dist1[x.first + i][x.second] > dist1[x.first][x.second] + 1)
					{
						dist1[x.first + i][x.second] = dist1[x.first][x.second] + 1;
						q1.push_back({ x.first + i, x.second });
					}
				}
				if (x.second + i < w && matr[x.first][x.second + i])
				{
					if (dist1[x.first][x.second + i] > dist1[x.first][x.second] + 1)
					{
						dist1[x.first][x.second + i] = dist1[x.first][x.second] + 1;
						q1.push_back({ x.first, x.second + i });
					}
				}
			}
		}

		if (dist1[x2 - 1][y2 - 1] == 1e9)
		{
			cout << -1;
			return;
		}

		deque<pair<int, int>> q;
		vector<vector<int>> dist(h, vector<int>(w, 1e9));
		dist[x1 - 1][y1 - 1] = 0;
		q.push_back({ x1 - 1, y1 - 1 });
		while (!q.empty())
		{
			pair<int, int> x = q.front();
			if (x.first == x2 - 1 && x.second == y2 - 1)
			{
				cout << dist[x2 - 1][y2 - 1];
				return;
			}
			q.pop_front();
			vector<bool> ok(4, true);
			for (int i = 1;; ++i)
			{
				if (!ok[0] && !ok[1] && !ok[2] && !ok[3])
				{
					break;
				}
				if (x.first - i >= 0 && ok[0])
				{
					if (!matr[x.first - i][x.second])
					{
						ok[0] = false;
					}
					else if (dist[x.first - i][x.second] > dist[x.first][x.second] + (i + k - 1) / k)
					{
						dist[x.first - i][x.second] = dist[x.first][x.second] + (i + k - 1) / k;
						q.push_back({ x.first - i, x.second });
					}
					else
					{
						ok[0] = false;
					}
				}
				else
				{
					ok[0] = false;
				}
				if (x.second - i >= 0 && ok[1])
				{
					if (!matr[x.first][x.second - i])
					{
						ok[1] = false;
					}
					else if (dist[x.first][x.second - i] > dist[x.first][x.second] + (i + k - 1) / k)
					{
						dist[x.first][x.second - i] = dist[x.first][x.second] + (i + k - 1) / k;
						q.push_back({ x.first, x.second - i });
					}
					else
					{
						ok[1] = false;
					}
				}
				else
				{
					ok[1] = false;
				}
				if (x.first + i < h && ok[2])
				{
					if (!matr[x.first + i][x.second])
					{
						ok[2] = false;
					}
					else if (dist[x.first + i][x.second] > dist[x.first][x.second] + (i + k - 1) / k)
					{
						dist[x.first + i][x.second] = dist[x.first][x.second] + (i + k - 1) / k;
						q.push_back({ x.first + i, x.second });
					}
					else
					{
						ok[2] = false;
					}
				}
				else
				{
					ok[2] = false;
				}
				if (x.second + i < w && ok[3])
				{
					if (!matr[x.first][x.second + i])
					{
						ok[3] = false;
					}
					else if (dist[x.first][x.second + i] > dist[x.first][x.second] + (i + k - 1) / k)
					{
						dist[x.first][x.second + i] = dist[x.first][x.second] + (i + k - 1) / k;
						q.push_back({ x.first, x.second + i });
					}
					else
					{
						ok[3] = false;
					}
				}
				else
				{
					ok[3] = false;
				}
			}
		}
	}
}

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	auto start = system_clock::now();

	solve();

	auto end = system_clock::now();
	cerr << "Time: " << duration_cast<milliseconds> (end - start).count() << "ms" << endl;
}


Measured memory_bytes: 20680