import java.util.Scanner

class Queue[A](ie:List[A]=Nil, id:List[A]=Nil) {
  private var enqueue:List[A] = ie
  private var dequeue:List[A] = id
  def enque(x:A) = x::enqueue
  def deque():Option[A] = {
    (enqueue, dequeue) match {
      case (Nil, Nil) => None
      case (_, d::dl) => {dequeue=dl; Some(d)}
      case (e::el, Nil) => {dequeue=el.reverse; enqueue=Nil; Some(e)}
    }
  }
  // def toStr():String = "eq:"+enqueue.toString+" dq:"+dequeue.toString
  def enqueList(l:List[A]) = enqueue = l:::enqueue
}

object Main extends App {
  // def readALine(c:Int, ac:List[Int]):List[Int] =
  //   if (c > 0) readALine(c-1, sc.nextInt::ac) else ac.reverse
  // def readLines(r:Int, c:Int, ac:List[List[Int]]):List[List[Int]] =
  //   if (r > 0) readLines(r-1, c, readALine(c, Nil)::ac) else ac.reverse
  def readLines(r:Int, ac:List[Array[Char]]):Array[Array[Char]] =
    if (r > 0) readLines(r-1, sc.next.toCharArray::ac) else ac.reverse.toArray
  val sc = new Scanner(System.in)
  val H,W,K = sc.nextInt
  val Sx,Sy,Ex,Ey = sc.nextInt
  val ls = readLines(H, Nil)

  type Cell = Option[Int]
  type Pos = (Int,Int)

  class World(speed:Int, hight:Int, width:Int, ob:Array[Array[Char]]) {
    private val worldMap = ob
    private val h = hight
    private val w = width
    private val k = speed
    private var cells:Array[Array[Cell]] = Array.fill(h)(Array.fill(w)(None))
    def reachables(p:Pos):List[Pos] = {
      def reachable(p:Pos):Boolean = worldMap(p._1)(p._2)== '.'
      def iter(k:Int, pred:Pos=>Boolean, next:Pos=>Pos, p:Pos, ac:List[Pos]):List[Pos] = {
        val q = next(p)
        if (k > 0 && pred(q) && reachable(q))
          if (visited(q)) iter(k-1, pred, next, q, ac) else iter(k-1, pred, next, q, q::ac)
        else ac
      }
      val dl = iter(k,(p:Pos)=> p._1 < h,(p:Pos)=>(p._1+1,p._2),p,Nil)
      val ul = iter(k,(p:Pos)=> p._1 >=0,(p:Pos)=>(p._1-1,p._2),p,dl)
      val rl = iter(k,(p:Pos)=> p._2 < w,(p:Pos)=>(p._1,p._2+1),p,ul)
      val ll = iter(k,(p:Pos)=> p._2 >=0,(p:Pos)=>(p._1,p._2-1),p,rl)
      // println(s"ll:$ll")
      ll.reverse
    }
    def visited(p:Pos):Boolean = { val (x,y) = p; cells(x)(y) != None }
    def visitCell(p:Pos, step:Int) = { val (x,y) = p; cells(x)(y) = Some(step) }
    def visitCells(l:List[Pos], step:Int) = l.foreach((p)=>cells(p._1)(p._2) = Some(step))
    def cell(p:Pos):Cell =  { val (x,y) = p; cells(x)(y) }
    def printMap() = worldMap.foreach((x) => println(x.mkString("")))
  }

  def bfs(que:Queue[Pos], goal:Pos):Int = {
    // println(que.toStr)
    que.deque() match {
      case None => -1
      case Some(p) => {
        val step =world.cell(p).get
        val nexts = world.reachables(p)
        if (nexts.contains(goal)) step+1 else {
          que.enqueList(nexts)
          world.visitCells(nexts,step+1)
          // world.printMap()
          bfs(que, goal)
        }
      }
    }
  }

  // ls.foreach((x) => println(x.mkString("")))

  val start = (Sx-1,Sy-1)
  val goal  = (Ex-1,Ey-1)
  val que = new Queue[Pos](Nil, List(start))
  val world = new World(K, H, W, ls)
  world.visitCell(start, 0)
  println(bfs(que, goal))
}