/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author aryssoncf
 */



// Taken from: https://github.com/bqi343/USACO/blob/master/Implementations/content/contest/templateShort.cpp

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ull> vul;
typedef vector<ll> vl;
typedef vector<pii> vpii;

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define F0R(i, a) FOR(i,0,a)
#define ROF(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i, a) ROF(i,0,a)
#define trav(a, x) for (auto& a: x)

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize

#define mp make_pair
#define pb push_back
#define f first
#define s second

const int MOD = 1e9 + 7; // 998244353; // = (119<<23)+1
const int MX = 2e5 + 5;

template<class T>
bool ckmin(T &a, const T &b) {
    return a > b ? a = b, 1 : 0;
}

template<class T>
bool ckmax(T &a, const T &b) {
    return a < b ? a = b, 1 : 0;
}

mt19937 rng((uint32_t) chrono::steady_clock::now().time_since_epoch().count());


//
// Created by aryssoncf on 28/10/2019.
//

#include <type_traits>


#include <iterator>
#include <utility>

template<typename T>
constexpr auto hasBegin(int) -> decltype(std::begin(std::declval<T>()), true) {
    return true;
}

constexpr bool hasBegin(...) {
    return false;
}

template<typename T>
using IsContainer = std::integral_constant<bool, hasBegin<T>(0)>;


#ifndef JHELPER_EXAMPLE_PROJECT_IO_HPP
#define JHELPER_EXAMPLE_PROJECT_IO_HPP

#endif //JHELPER_EXAMPLE_PROJECT_IO_HPP

template<typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
    for (T &element: vec) {
        is >> element;
    }
    return is;
}

template<typename T, typename U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
    is >> p.first;
    is >> p.second;
    return is;
}

template<class X, class Y>
std::ostream &operator<<(std::ostream &os, std::pair<X, Y> const &p) {
    return os << p.first << " " << p.second;
}

template<class Ch, class Tr, class Container>
std::basic_ostream<Ch, Tr> &operator<<(std::basic_ostream<Ch, Tr> &os, Container const &x) {
    bool first = true;
    for (auto &y : x) {
        if (first) {
            first = false;
        } else {
            os << " ";
        }
        os << y;
    }
    return os;
}

using namespace std;

class FPondSkater {

    int N, M, K;
    int X1, Y1, X2, Y2;
    vector<vector<set<int>>> row, col;
    vector<vi> trow, tcol;
    vector<string> grid;

    void del(int r, int c) {
        int p = upper_bound(all(trow[r]), c) - trow[r].begin() - 1;
        row[r][p].erase(c);
        int q = upper_bound(all(tcol[c]), r) - tcol[c].begin() - 1;
        col[c][q].erase(r);
    }

    int bfs() {
        queue<pii> Q;
        vector<vi> dist(N, vi(M, -1));
        del(X1, Y1);
        dist[X1][Y1] = 0;
        Q.push({X1, Y1});
        while (not Q.empty()) {
            int x, y;
            tie(x, y) = Q.front();
            Q.pop();
            int d = dist[x][y];
            {
                int y1 = y - K, y2 = y + K, px = upper_bound(all(trow[x]), y) - trow[x].begin() - 1;
                set<int> &aux = row[x][px];
                while (true) {
                    auto it = aux.lower_bound(y1);
                    if (it == aux.end() or *it > y2) {
                        break;
                    }
                    int yy = *it;
                    del(x, yy);
                    dist[x][yy] = d + 1;
                    Q.push({x, yy});
                }
            }
            {
                int x1 = x - K, x2 = x + K, py = upper_bound(all(tcol[y]), x) - tcol[y].begin() - 1;
                set<int> &aux = col[y][py];
                while (true) {
                    auto it = aux.lower_bound(x1);
                    if (it == aux.end() or *it > x2) {
                        break;
                    }
                    int xx = *it;
                    del(xx, y);
                    dist[xx][y] = d + 1;
                    Q.push({xx, y});
                }
            }
        }
        return dist[X2][Y2];
    }

public:
    void solve(std::istream &in, std::ostream &out) {
        in >> N >> M >> K;
        in >> X1 >> Y1 >> X2 >> Y2;
        X1--, Y1--, X2--, Y2--;
        row.resize(N);
        trow.resize(N);
        col.resize(M);
        tcol.resize(M);
        grid.resize(N);
        in >> grid;
        FOR(i, 0, N) {
            set<int> aux;
            FOR(j, 0, M + 1) {
                if (j == M or grid[i][j] == '@') {
                    if (not aux.empty()) {
                        row[i].pb(aux);
                        trow[i].pb(*aux.begin());
                        aux.clear();
                    }
                } else {
                    aux.insert(j);
                }
            }
        }
        FOR(j, 0, M) {
            set<int> aux;
            FOR(i, 0, N + 1) {
                if (i == N or grid[i][j] == '@') {
                    if (not aux.empty()) {
                        col[j].pb(aux);
                        tcol[j].pb(*aux.begin());
                        aux.clear();
                    }
                } else {
                    aux.insert(i);
                }
            }
        }
        int res = bfs();
        out << res << '\n';
    }

    void setup() {}
};


int main() {
    std::ios_base::sync_with_stdio(false);
    FPondSkater solver;
    solver.setup();
    std::istream &in(std::cin);
    std::ostream &out(std::cout);
    in.tie(nullptr);
    out << std::fixed;
    out.precision(20);
    solver.solve(in, out);
    return 0;
}


Measured memory_bytes: 245928