#include <bits/stdc++.h>

using ll   = long long;
using uint = unsigned int;
using ull  = unsigned long long;
using ld   = long double;
template<typename T, int n>
using arr = T (&)[n];
template<typename T, int n>
using c_arr = const T (&)[n];
template<typename T>
using max_heap = std::priority_queue<T>;
template<typename T>
using min_heap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
constexpr int popcount(const ull v) { return v ? __builtin_popcountll(v) : 0; }
constexpr int log2p1(const ull v) { return v ? 64 - __builtin_clzll(v) : 0; }
constexpr int lsbp1(const ull v) { return __builtin_ffsll(v); }
constexpr int clog(const ull v) { return v ? log2p1(v - 1) : 0; }
constexpr ull ceil2(const ull v) { return 1ULL << clog(v); }
constexpr ull floor2(const ull v) { return v ? (1ULL << (log2p1(v) - 1)) : 0ULL; }
constexpr bool btest(const ull mask, const int ind) { return (mask >> ind) & 1ULL; }
template<typename T> void bset(T& mask, const int ind) { mask |= ((T)1 << ind); }
template<typename T> void breset(T& mask, const int ind) { mask &= ~((T)1 << ind); }
template<typename T> void bflip(T& mask, const int ind) { mask ^= ((T)1 << ind); }
template<typename T> void bset(T& mask, const int ind, const bool b) { (b ? bset(mask, ind) : breset(mask, ind)); }
template<typename T> bool chmin(T& a, const T& b) { return (a > b ? a = b, true : false); }
template<typename T> bool chmax(T& a, const T& b) { return (a < b ? a = b, true : false); }

template<typename T> constexpr T inf_v      = std::numeric_limits<T>::max() / 4;
template<typename Real> constexpr Real pi_v = Real{3.141592653589793238462643383279502884};
constexpr ull TEN(const int n) { return n == 0 ? 1ULL : TEN(n - 1) * 10ULL; }
template<typename F> struct fix : F
{
    fix(F&& f) : F{std::forward<F>(f)} {}
    template<typename... Args> auto operator()(Args&&... args) const { return F::operator()(*this, std::forward<Args>(args)...); }
};
class printer
{
public:
    printer(std::ostream& os_ = std::cout) : os{os_} {}
    template<typename T> int operator()(const T& v) { return os << v, 0; }
    template<typename T> int operator()(const std::vector<T>& vs)
    {
        for (int i = 0; i < (int)vs.size(); i++) { os << (i ? " " : ""), this->operator()(vs[i]); }
        return 0;
    }
    template<typename T> int operator()(const std::vector<std::vector<T>>& vss)
    {
        for (int i = 0; i < (int)vss.size(); i++) { os << (0 <= i or i + 1 < (int)vss.size() ? "\n" : ""), this->operator()(vss[i]); }
        return 0;
    }
    template<typename T, typename... Args> int operator()(const T& v, const Args&... args) { return this->operator()(v), os << ' ', this->operator()(args...), 0; }
    template<typename... Args> int ln(const Args&... args) { return this->operator()(args...), os << '\n', 0; }
    template<typename... Args> int el(const Args&... args) { return this->operator()(args...), os << std::endl, 0; }
    template<typename... Args> int fmt(const std::string& s, const Args&... args) { return rec(s, 0, args...); }

private:
    int rec(const std::string& s, int index) { return os << s.substr(index, s.size()), 0; }
    template<typename T, typename... Args> int rec(const std::string& s, int index, const T& v, const Args&... args) { return index == s.size() ? 0 : s[index] == '%' ? (this->operator()(v), rec(s, index + 1, args...)) : (os << s[index], rec(s, index + 1, v, args...)); }
    std::ostream& os;
};
printer out;

template<typename T, typename F> std::vector<T> generated(const int n, F f)
{
    std::vector<T> ans(n);
    return std::generate(ans.begin(), ans.end(), f), ans;
}
std::vector<int> ioted(const int n, const int offset = 0)
{
    std::vector<int> ans(n);
    return std::iota(ans.begin(), ans.end(), offset), ans;
}
template<typename Vs> Vs reversed(const Vs& vs)
{
    auto ans = vs;
    return std::reverse(ans.begin(), ans.end()), ans;
}
template<typename T, typename F = std::less<T>> std::vector<T> sorted(const std::vector<T>& vs, F comp = F{})
{
    auto ans = vs;
    return std::sort(ans.begin(), ans.end(), comp), ans;
}
template<typename F> std::vector<int> sorted_iota(const int n, F comp = F{}, const int offset = 0) { return sorted(ioted(n, offset), comp); }
class scanner
{
public:
    scanner(std::istream& is_ = std::cin) : is{is_} { is.tie(nullptr), std::ios::sync_with_stdio(false); }
    template<typename T> T val()
    {
        static T v;
        return is >> v, v;
    }
    template<typename T> T val(const T offset) { return val<T>() - offset; }
    template<typename T> std::vector<T> vec(const int n)
    {
        return generated<T>(n, [&] { return val<T>(); });
    }
    template<typename T> std::vector<T> vec(const int n, const T offset)
    {
        return generated<T>(n, [&] { return val<T>(offset); });
    }
    template<typename T> std::vector<std::vector<T>> vvec(const int n0, const int n1)
    {
        return generated<std::vector<T>>(n0, [&] { return vec<T>(n1); });
    }
    template<typename T> std::vector<std::vector<T>> vvec(const int n0, const int n1, const T offset)
    {
        return generated<std::vector<T>>(n0, [&] { return vec<T>(n1, offset); });
    }
    template<typename... Args> auto tup() { return std::tuple<std::decay_t<Args>...>{val<Args>()...}; }
    template<typename... Args> auto tup(const Args&... offsets) { return std::tuple<std::decay_t<Args>...>{val<Args>(offsets)...}; }

private:
    std::istream& is;
};
scanner in;
#    define SHOW(...) static_cast<void>(0)

template<typename T, typename Int, int n, int i> auto make_v(typename std::enable_if<(i == n), c_arr<Int, n>>::type, const T& v = T{}) { return v; }
template<typename T, typename Int, int n, int i> auto make_v(typename std::enable_if<(i < n), c_arr<Int, n>>::type szs, const T& v = T{}) { return std::vector<decltype(make_v<T, Int, n, i + 1>(szs, v))>(szs[i], make_v<T, Int, n, i + 1>(szs, v)); }
template<typename T, typename Int, int n> auto make_v(c_arr<Int, n> szs, const T& t = T{}) { return make_v<T, Int, n, 0>(szs, t); }
int main()
{
    const auto [H, W, K]        = in.tup<int, int, int>();
    const auto [y1, x1, y2, x2] = in.tup<int, int, int, int>(1, 1, 1, 1);
    const auto css              = in.vec<std::string>(H);
    using pll                   = std::pair<ll, ll>;                                  // かき回数,最後のかきからの距離
    auto dp                     = make_v<pll>({H, W, 4}, pll{inf_v<ll>, inf_v<ll>});  // 0123:下右上左
    dp[y1][x1][0] = dp[y1][x1][1] = dp[y1][x1][2] = dp[y1][x1][3] = {0, 0};
    using P                                                       = std::pair<std::pair<int, int>, int>;
    using ppP                                                     = std::pair<pll, P>;
    min_heap<ppP> Q;
    for (int d = 0; d < 4; d++) { dp[y1][x1][d] = {0, K}, Q.push(ppP{{0, K}, {{y1, x1}, d}}); }
    while (not Q.empty()) {
        const auto top = Q.top();
        Q.pop();
        const auto cost   = top.first;
        const auto [d, l] = cost;
        const auto [y, x] = top.second.first;
        const int dir     = top.second.second;
        if (dp[y][x][dir] < cost) { continue; }
        constexpr int dys[] = {1, 0, -1, 0};
        constexpr int dxs[] = {0, 1, 0, -1};
        for (int ndir = 0; ndir < 4; ndir++) {
            const int dy = dys[ndir], dx = dxs[ndir];
            const int ny = y + dy, nx = x + dx;
            if (ny < 0 or ny >= H or nx < 0 or nx >= W or css[ny][nx] == '@') { continue; }
            if (dir == ndir) {
                const ll nd     = (l == K ? d + 1 : d);
                const ll nl     = (l == K ? 1 : l + 1);
                const pll ncost = {nd, nl};
                if (dp[ny][nx][ndir] <= ncost) { continue; }
                dp[ny][nx][ndir] = ncost;
                Q.push({ncost, {{ny, nx}, ndir}});
            } else {
                const ll nd     = d + 1;
                const ll nl     = 1;
                const pll ncost = {nd, nl};
                if (dp[ny][nx][ndir] <= ncost) { continue; }
                dp[ny][nx][ndir] = ncost;
                Q.push({ncost, {{ny, nx}, ndir}});
            }
        }
    }
    for (int y = 0; y < H; y++) {
        for (int x = 0; x < W; x++) {
            pll min = {inf_v<ll>, inf_v<ll>};
            for (int d = 0; d < 4; d++) { chmin(min, dp[y][x][d]); }
            SHOW(y, x, min);
        }
    }
    pll ans = {inf_v<ll>, inf_v<ll>};
    for (int d = 0; d < 4; d++) { chmin(ans, dp[y2][x2][d]); }
    if (ans == pll{inf_v<ll>, inf_v<ll>}) {
        out.ln(-1);
    } else {
        out.ln(ans.first);
    }

    return 0;
}


Measured memory_bytes: 208188