Problem:
Score : 600 points

Problem Statement

Snuke, a water strider, lives in a rectangular pond that can be seen as a grid with H east-west rows and W north-south columns. Let (i,j) be the square at the i-th row from the north and j-th column from the west.

Some of the squares have a lotus leaf on it and cannot be entered.
The square (i,j) has a lotus leaf on it if c_{ij} is @, and it does not if c_{ij} is ..

In one stroke, Snuke can move between 1 and K squares (inclusive) toward one of the four directions: north, east, south, and west.
The move may not pass through a square with a lotus leaf. Moving to such a square or out of the pond is also forbidden.

Find the minimum number of strokes Snuke takes to travel from the square (x_1,y_1) to (x_2,y_2).
If the travel from (x_1,y_1) to (x_2,y_2) is impossible, point out that fact.

Constraints

1 \leq H,W,K \leq 10^6

H \times W \leq 10^6

1 \leq x_1,x_2 \leq H

1 \leq y_1,y_2 \leq W

x_1 \neq x_2 or y_1 \neq y_2.

c_{i,j} is . or @.

c_{x_1,y_1} = .

c_{x_2,y_2} = .

All numbers in input are integers.

Input

Input is given from Standard Input in the following format:

H W K
x_1 y_1 x_2 y_2
c_{1,1}c_{1,2} .. c_{1,W}
c_{2,1}c_{2,2} .. c_{2,W}
:
c_{H,1}c_{H,2} .. c_{H,W}

Output

Print the minimum number of strokes Snuke takes to travel from the square (x_1,y_1) to (x_2,y_2), or print -1 if the travel is impossible.

Sample Input 1

3 5 2
3 2 3 4
.....
.@..@
..@..

Sample Output 1

5

Initially, Snuke is at the square (3,2).
He can reach the square (3, 4) by making five strokes as follows:

From (3, 2), go west one square to (3, 1).

From (3, 1), go north two squares to (1, 1).

From (1, 1), go east two squares to (1, 3).

From (1, 3), go east one square to (1, 4).

From (1, 4), go south two squares to (3, 4).

Sample Input 2

1 6 4
1 1 1 6
......

Sample Output 2

2

Sample Input 3

3 3 1
2 1 2 3
.@.
.@.
.@.

Sample Output 3

-1

Solution in Rust (1.42.0) (judge verdict: Accepted)

use std::cmp::*;
use input_mcr::*;
use std::collections::VecDeque;
use field::*;

fn main() {
    input! {
        h: usize,
        w: usize,
        d: usize,
        sy: usize1,
        sx: usize1,
        ty: usize1,
        tx: usize1,
        field: [chars; h],
    }
    let s = Pos{x:sx,y:sy};
    let t = Pos{x:tx,y:ty};
    let field = Field::from_vec_vec(&field);
    let inf = 1i64 << 50;
    let mut dist = Field::<i64>::new(h,w,inf);
    dist[s] = 0;
    let mut q = VecDeque::new();
    q.push_back(s);
    while let Some(p) = q.pop_front() {
        for &dir in &DIRS {
            for p2 in field.nexts(p, dir).take(d) {
                if field[p2] == '@' {
                    break;
                }
                if dist[p2] > dist[p] + 1 {
                    dist[p2] = dist[p] + 1;
                    q.push_back(p2);
                }
                if dist[p2] <= dist[p] {
                    break;
                }
            }
        }
    }
    let res = dist[t];
    if res >= inf / 2 {
        println!("-1");
    } else {
        println!("{}", res);
    }
}
pub mod input_mcr {
    // ref: tanakh <https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8>
    #[macro_export(local_inner_macros)]
    macro_rules! input {
        (source = $s:expr, $($r:tt)*) => {
            let mut parser = Parser::from_str($s);
            input_inner!{parser, $($r)*}
        };
        (parser = $parser:ident, $($r:tt)*) => {
            input_inner!{$parser, $($r)*}
        };
        (new_stdin_parser = $parser:ident, $($r:tt)*) => {
            let stdin = std::io::stdin();
            let reader = std::io::BufReader::new(stdin.lock());
            let mut $parser = Parser::new(reader);
            input_inner!{$parser, $($r)*}
        };
        ($($r:tt)*) => {
            input!{new_stdin_parser = parser, $($r)*}
        };
    }
    
    #[macro_export(local_inner_macros)]
    macro_rules! input_inner {
        ($parser:ident) => {};
        ($parser:ident, ) => {};
        ($parser:ident, $var:ident : $t:tt $($r:tt)*) => {
            let $var = read_value!($parser, $t);
            input_inner!{$parser $($r)*}
        };
    }
    
    #[macro_export(local_inner_macros)]
    macro_rules! read_value {
        ($parser:ident, ( $($t:tt),* )) => {
            ( $(read_value!($parser, $t)),* )
        };
        ($parser:ident, [ $t:tt ; $len:expr ]) => {
            (0..$len).map(|_| read_value!($parser, $t)).collect::<Vec<_>>()
        };
        ($parser:ident, chars) => {
            read_value!($parser, String).chars().collect::<Vec<char>>()
        };
        ($parser:ident, char_) => {
            read_value!($parser, String).chars().collect::<Vec<char>>()[0]
        };
        ($parser:ident, usize1) => {
            read_value!($parser, usize) - 1
        };
        ($parser:ident, line) => {
            $parser.next_line()
        };
        ($parser:ident, line_) => {
            $parser.next_line().chars().collect::<Vec<char>>()
        };
        ($parser:ident, $t:ty) => {
            $parser.next::<$t>().expect("Parse error")
        };
    }
    
    use std::io;
    use std::io::BufRead;
    use std::str;
    use std::collections::VecDeque;
    
    pub struct Parser<R> {
        pub reader: R,
        buf: VecDeque<u8>,
        parse_buf: Vec<u8>,
    }
    
    impl Parser<io::Empty> {
        pub fn from_str(s: &str) -> Parser<io::Empty> {
            Parser {
                reader: io::empty(),
                buf: VecDeque::from(s.as_bytes().to_vec()),
                parse_buf: vec![],
            }
        }
    }
    
    impl<R: BufRead> Parser<R> {
        pub fn new(reader: R) -> Parser<R> {
            Parser {
                reader: reader,
                buf: VecDeque::new(),
                parse_buf: vec![],
            }
        }
        pub fn update_buf(&mut self) {
            loop {
                let (len, complete) = {
                    let buf2 = self.reader.fill_buf().unwrap();
                    self.buf.extend(buf2.iter());
                    let len = buf2.len();
                    (len, buf2.last() < Some(&0x20))
                };
                self.reader.consume(len);
                if complete {
                    break;
                }
            }
        }
        pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {
            loop {
                while let Some(c) = self.buf.pop_front() {
                    if c > 0x20 {
                        self.buf.push_front(c);
                        break;
                    }
                }
                self.parse_buf.clear();
                while let Some(c) = self.buf.pop_front() {
                    if c <= 0x20 {
                        self.buf.push_front(c);
                        break;
                    } else {
                        self.parse_buf.push(c);
                    }
                }
                if self.parse_buf.is_empty() {
                    self.update_buf();
                } else {
                    return unsafe { str::from_utf8_unchecked(&self.parse_buf) }.parse::<T>();
                }
            }
        }
        pub fn next_line(&mut self) -> String {
            loop {
                while let Some(c) = self.buf.pop_front() {
                    if c >= 0x20 {
                        self.buf.push_front(c);
                        break;
                    }
                }
                self.parse_buf.clear();
                while let Some(c) = self.buf.pop_front() {
                    if c < 0x20 {
                        self.buf.push_front(c);
                        break;
                    } else {
                        self.parse_buf.push(c);
                    }
                }
                if self.parse_buf.is_empty() {
                    self.update_buf();
                } else {
                    return unsafe { str::from_utf8_unchecked(&self.parse_buf) }.to_string();
                }
            }
        }
    }
}
pub mod field {
    use std::ops::{Index,IndexMut};
    use std::iter::Iterator;
    
    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum Dir {
        U,
        R,
        D,
        L,
    }
    
    pub const DIRS: [Dir; 4] = [Dir::U, Dir::R, Dir::D, Dir::L];
    
    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
    pub struct Pos {
        pub x: usize,
        pub y: usize,
    }
    
    pub struct Field<T> {
        h: usize,
        w: usize,
        field: Vec<T>,
    }
    
    pub struct N4 {
        i: usize,
        x: usize,
        y: usize,
        h: usize,
        w: usize,
    }
    
    impl Iterator for N4 {
        type Item = Pos;
        fn next(&mut self) -> Option<Pos> {
            let dx = [0, 1, 0, -1];
            let dy = [-1, 0, 1, 0];
            while self.i < 4 {
                let nx = self.x as i64 + dx[self.i];
                let ny = self.y as i64 + dy[self.i];
                if 0 <= nx && nx < self.w as i64 && 0 <= ny && ny < self.h as i64 {
                    self.i += 1;
                    return Some(Pos {
                        x: nx as usize,
                        y: ny as usize,
                    });
                }
                self.i += 1;
            }
            None
        }
    }
    
    pub struct Nexts<'a,T> {
        field: &'a Field<T>,
        pos: Pos,
        dir: Dir,
    }
    
    impl<'a,T:Clone+Copy+Default> Iterator for Nexts<'a,T> {
        type Item = Pos;
        fn next(&mut self) -> Option<Pos> {
            let pos2 = self.field.next(self.pos, self.dir);
            if let Some(pos2) = pos2 {
                self.pos = pos2;
                Some(pos2)
            } else {
                None
            }
        }
    }
    
    impl<T:Clone+Copy+Default> Field<T> {
        pub fn new(h: usize, w: usize, default: T) -> Field<T> {
            Field::<T> {
                h,
                w,
                field: vec![default; h*w],
            }
        }
        pub fn from_vec_vec(xss: &Vec<Vec<T>>) -> Field<T> {
            let h = xss.len();
            let w = xss[0].len();
            let mut field = vec![];
            for y in 0..h {
                for x in 0..w {
                    field.push(xss[y][x]);
                }
            }
            Field::<T> {
                h,
                w,
                field,
            }
        }
        pub fn n4(&self, pos: Pos) -> N4 {
            N4 {
                i: 0,
                x: pos.x,
                y: pos.y,
                h: self.h,
                w: self.w
            }
        }
        pub fn next(&self, pos: Pos, dir: Dir) -> Option<Pos> {
            match dir {
                Dir::U => {
                    if pos.y > 0 {
                        return Some(Pos {
                            x: pos.x,
                            y: pos.y-1,
                        })
                    }
                }
                Dir::R => {
                    if pos.x+1 < self.w {
                        return Some(Pos {
                            x: pos.x+1,
                            y: pos.y
                        })
                    }
                }
                Dir::D => {
                    if pos.y+1 < self.h {
                        return Some(Pos {
                            x: pos.x,
                            y: pos.y+1,
                        })
                    }
                }
                Dir::L => {
                    if pos.x > 0 {
                        return Some(Pos {
                            x: pos.x-1,
                            y: pos.y,
                        })
                    }
                }
            }
            None
        }
        pub fn nexts<'a>(&'a self, pos: Pos, dir: Dir) -> Nexts<'a, T> {
            Nexts {
                field: self,
                pos,
                dir,
            }
        }
    }
    
    impl<T:Clone+Copy+Default> Index<Pos> for Field<T> {
        type Output = T;
        fn index(&self, pos: Pos) -> &T {
            &self.field[pos.y*self.w+pos.x]
        }
    }
    
    impl<T:Clone+Copy+Default> IndexMut<Pos> for Field<T> {
        fn index_mut(&mut self, pos: Pos) -> &mut T {
            &mut self.field[pos.y*self.w+pos.x]
        }
    }
}