#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& o) {
    out << "(" << o.first << "," << o.second << ")";
    return out;
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& V) {
    for (int i = 0; i < V.size(); i++) {
        out << V[i];
        if (i != V.size() - 1) out << " ";
    }
    return out;
}
template <class T>
ostream& operator<<(ostream& out, const vector<vector<T>>& Mat) {
    for (int i = 0; i < Mat.size(); i++) {
        if (i != 0) out << endl;
        out << Mat[i];
    }
    return out;
}
template <class S, class T>
ostream& operator<<(ostream& out, const map<S, T>& mp) {
    out << "{ ";
    for (auto it = mp.begin(); it != mp.end(); it++) {
        out << it->first << ":" << it->second;
        if (mp.size() - 1 != distance(mp.begin(), it)) out << ", ";
    }
    out << " }";
    return out;
}
template <typename T>
vector<T> make_v(size_t a) {
    return vector<T>(a);
}
template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T& t, const V& v) {
    t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T& t, const V& v) {
    for (auto& e : t) fill_v(e, v);
}
/*
 <url:>
 問題文============================================================
 =================================================================
 解説=============================================================
 ================================================================
 */

template <class Type>
Type solve(Type res = Type()) {
    int H, W, K;
    cin >> H >> W >> K;

    int x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    x1--;
    y1--;
    x2--;
    y2--;
    vector<vector<char>> masu(H, vector<char>(W));
    for (auto& vec : masu) for (auto& in : vec) cin >> in;

    auto dist = make_v<ll>(H, W, 4);
    fill_v(dist, LINF);

    using Item = tuple<ll, int, int, int>;
    priority_queue<Item, vector<Item>, greater<Item>> pq;
    int D[4] = {1, 0, -1, 0};
    for (int k = 0; k < 4; k++) {
        pq.emplace(0, x1, y1, k);
        dist[x1][y1][k] = 0;
    }

    while (pq.size()) {
        int cost, x, y, dir;
        tie(cost, x, y, dir) = pq.top();
        pq.pop();
        if (dist[x][y][dir] < cost) continue;

        for (int k = 0; k < 4; k++) {
            if (k == dir) {
                int nx = x + D[k];
                int ny = y + D[k ^ 1];

                if (nx < 0 || nx >= H || ny < 0 || ny >= W) continue;
                if (masu[nx][ny] == '@') continue;
                if (dist[nx][ny][k] > dist[x][y][dir] + 1) {
                    dist[nx][ny][k] = dist[x][y][dir] + 1;
                    pq.emplace(dist[nx][ny][k], nx, ny, k);
                }
            } else {
                if (dist[x][y][k] > (dist[x][y][dir]+K-1)/K*K) {
                    dist[x][y][k] = (dist[x][y][dir]+K-1)/K*K;
                    pq.emplace(dist[x][y][k], x, y, k);
                }
            }
        }
    }

    // cout << dist[x2][y2] << endl;
    res = *min_element(dist[x2][y2].begin(), dist[x2][y2].end());
    if (res == LINF) res = -1;
    else{
        res = (res + K-1)/K;
    }
    return res;
}
int main(void) {
    cin.tie(0);
    ios::sync_with_stdio(false);
    // solve<ll>(0);
    cout << fixed << setprecision(12) << solve<ll>() << endl;
    return 0;
}

Measured memory_bytes: 144788