Olya loves energy drinks. She loves them so much that her room is full of empty cans from energy drinks.

Formally, her room can be represented as a field of *n* × *m* cells, each cell of which is empty or littered with cans.

Olya drank a lot of energy drink, so now she can run *k* meters per second. Each second she chooses one of the four directions (up, down, left or right) and runs from 1 to *k* meters in this direction. Of course, she can only run through empty cells.

Now Olya needs to get from cell (*x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>) to cell (*x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub>). How many seconds will it take her if she moves optimally?

It's guaranteed that cells (*x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>) and (*x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub>) are empty. These cells can coincide.
The first line contains three integers *n*, *m* and *k* (1 ≤ *n*, *m*, *k* ≤ 1000) — the sizes of the room and Olya's speed.

Then *n* lines follow containing *m* characters each, the *i*-th of them contains on *j*-th position "#", if the cell (*i*, *j*) is littered with cans, and "." otherwise.

The last line contains four integers *x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>, *x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub> (1 ≤ *x*<sub class="lower-index">1</sub>, *x*<sub class="lower-index">2</sub> ≤ *n*, 1 ≤ *y*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">2</sub> ≤ *m*) — the coordinates of the first and the last cells.
In the first sample Olya should run 3 meters to the right in the first second, 2 meters down in the second second and 3 meters to the left in the third second.

In second sample Olya should run to the right for 3 seconds, then down for 2 seconds and then to the left for 3 seconds.

Olya does not recommend drinking energy drinks and generally believes that this is bad.
3 4 4
....
###.
....
1 1 3 1
3
3 4 1
....
###.
....
1 1 3 1
8
2 2 1
.#
#.
1 1 2 2
-1
10 10 1
##########
#.........
#.#######.
#.#.....#.
#.#.###.#.
#.#.#.#.#.
#.#.#.#.#.
#.#.#...#.
#.#.#####.
#.#.......
6 6 10 2
48
10 10 3
##########
##########
##########
##########
##########
##########
##########
#########.
#########.
####..###.
10 6 10 5
1
10 10 3
...##..#..
#.#..#...#
..#.##.#..
##..#..#.#
..#...##..
.#.#.#....
#......#..
.#.####.##
......#...
.#.##...##
4 6 8 1
7
10 10 1000
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
7 6 1 3
2
10 10 1000
..........
..........
..........
..........
..........
..........
..........
..........
..........
.....#....
3 9 5 1
2
10 10 10
...#......
##.#.#####
...#...###
.#####.###
...#...###
##.#.#####
...#...###
.#####.###
.......###
##########
1 1 1 10
17
2 5 5
#####
##.##
2 3 2 3
0
4 4 4
...#
.#.#
....
##..
1 1 3 4
2
6 6 100
....##
.##.##
.##.##
......
###.##
###.##
1 1 4 6
2
#include <bits/stdc++.h>
using namespace std;

const int MAX = 1e6 + 10; 
const int OO = 0x3f3f3f3f;
const double EPS = 1e-9; 

#define bug(x) cout << #x << " = " << x << '\n'
#define FOR(i, a, n) for(int i = a; i < n; i++)
#define REP(i, n) FOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mt make_tuple
#define all(vetor) vetor.begin(), vetor.end()
//#define gc getchar_unlocked

typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ii, int> iii;

string grid[1005];

int x, y, xx, yy, n, m, k;
set<ii> s;

bool check(int l, int r)
{
    if(l >= 0 and l < n and r >= 0 and r < m) return true;
    return false;
}

int solve()
{
    queue<iii> q;
    q.push({{x, y}, 0});
    while(!q.empty())
    {
        int l = q.front().fi.fi, r = q.front().fi.se, d = q.front().se;
        q.pop();
        for(int i = 1; i <= k; i++)
            if(check(l-i, r))
            {
                if(grid[l-i][r] == '#') break;
                if(xx == l-i and yy == r) return d + 1;
                q.push({{l-i, r}, d + 1});
            }
        for(int i = 1; i <= k; i++)
            if(check(l, r + i))
            {
                if(grid[l][r + i] == '#') break;
                if(xx == l and yy == r + i) return d + 1;
                q.push({{l, r + i}, d + 1});
            }
        for(int i = 1; i <= k; i++)
            if(check(l + i, r))
            {
                if(grid[l + i][r] == '#') break;
                if(xx == l + i and yy == r) return d + 1;
                q.push({{l + i, r}, d + 1});
            }
        for(int i = 1; i <= k; i++)
            if(check(l, r - i))
            {
                if(grid[l][r - i] == '#') break;
                if(xx == l and yy == r - i) return d + 1;
                q.push({{l, r - i}, d + 1});
            }
    }
    return -1;
}

int main()
{
    cin >> n >> m >> k;
    REP(i, n) cin >> grid[i];
    cin >> x >> y >> xx >> yy;
    x--; y--; xx--; yy--;
    cout << solve() << '\n';
    
	return 0;
}