object Main extends App {
  val sc = new java.util.Scanner(System.in)
  val h, w, k = sc.nextInt()
  val x1, y1, x2, y2 = sc.nextInt()-1
  val c = Array.fill(h)(sc.next()).map(_.map(_ == '@').toArray)

  def compare(a: (Int, Int), b: (Int, Int)): Boolean = {
    if (a._1 == b._1) {
      a._2 < b._2
    } else {
      a._1 < b._1
    }
  }

  def shortestPath(sx: Int, sy: Int): Array[Array[Array[(Int, Int)]]] = {
    val sp = Array.fill(h, w, 4)((-1, 0))
    val dir = Array((1,0), (0,1), (-1,0), (0,-1))
    val heap = new BinaryHeap[(Int,Int,Int), (Int,Int)](4000000, compare)
    sp(sx)(sy)(0) = (0, 0)
    heap.add((sx, sy, 0), (0, 0))

    while (heap.nonEmpty) {
      val ((x1, y1, d1), (a, b)) = heap.pop()

      for (i <- -1 to 1) {
        val d2 = (d1+i+4) % 4
        val (x2, y2) = if (i == 0) {
          (x1 + dir(d2)._1, y1 + dir(d2)._2)
        } else {
          (x1, y1)
        }

        if (i != 0 || (0 <= x2 && x2 < h && 0 <= y2 && y2 < w && !c(x2)(y2))) {
          val costOld = sp(x2)(y2)(d2)
          val costNew = if (i == 0) {
            if (b == k-1) (a+1, 0) else (a, b+1)
          } else {
            if (b == 0) (a, 0) else (a+1, 0)
          }

          if (costOld._1 == -1) {
            sp(x2)(y2)(d2) = costNew
            heap.add((x2, y2, d2), costNew)
          } else if (compare(costNew, costOld)) {
            sp(x2)(y2)(d2) = costNew
            heap.add((x2, y2, d2), costNew)
          }
        }
      }
    }
    sp
  }

  class BinaryHeap[A, P](maxSize: Int, comparator: (P, P) => Boolean) {
    private val heap = Array.ofDim[(A, P)](maxSize)

    var size = 0
    def isEmpty: Boolean = size == 0
    def nonEmpty: Boolean = !isEmpty

    private def par(idx: Int): Int = (idx - 1) / 2
    private def left(idx: Int): Int = 2 * idx + 1
    private def right(idx: Int): Int = 2 * idx + 2

    private def isRoot(idx: Int): Boolean = idx == 0
    private def hasLeft(idx: Int): Boolean = left(idx) < size
    private def hasRight(idx: Int): Boolean = right(idx) < size

    private def swap(i: Int, j: Int): Unit = {
      val t = heap(i)
      heap(i) = heap(j)
      heap(j) = t
    }

    private def upHeap(idx: Int): Unit = {
      if (!isRoot(idx) && comparator(heap(idx)._2, heap(par(idx))._2)) {
        swap(idx, par(idx))
        upHeap(par(idx))
      }
    }

    private def downHeap(idx: Int): Unit = {
      if (hasLeft(idx)) {
        val t = if (hasRight(idx) && comparator(heap(right(idx))._2, heap(left(idx))._2)) {
          right(idx)
        } else {
          left(idx)
        }
        if (comparator(heap(t)._2, heap(idx)._2)) {
          swap(idx, t)
          downHeap(t)
        }
      }
    }

    def add(a: A, p: P): Unit = {
      if (size >= maxSize) {
        throw new UnsupportedOperationException()
      } else {
        size += 1
        heap(size - 1) = (a, p)
        upHeap(size - 1)
      }
    }

    def pop(): (A, P) = {
      if (isEmpty) {
        throw new UnsupportedOperationException()
      } else {
        val head = heap(0)
        heap(0) = heap(size - 1)
        size -= 1
        downHeap(0)
        head
      }
    }
  }

  val sp = shortestPath(x1, y1)
  println(sp(x2)(y2).map{case (a, b) => a + (if (b == 0) 0 else 1)}.min)
}
