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)
  val m = 1000000L

  def shortestPath(sx: Int, sy: Int): Array[Long] = {
    val sp = Array.fill(4 * h * w)(-m)
    val dir = Array((1,0), (0,1), (-1,0), (0,-1))
    val heap = new BinaryHeap[Int, Long]((4 * m).toInt, (a, b) => a < b)
    sp(sx * w + sy) = 0
    heap.add(sx * w + sy, 0)

    while (heap.nonEmpty) {
      val (z1, ab) = heap.pop()
      val d1 = z1 / (h * w)
      val x1 = (z1 % (h * w)) / w
      val y1 = z1 % w
      val a = ab / m
      val b = ab % m

      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(d2 * (h * w) + x2 * w + y2)
          val costNew = if (i == 0) {
            if (b == k-1) (a+1) * m else a * m + (b+1)
          } else {
            if (b == 0) a * m else (a+1) * m
          }

          if (costOld == -m) {
            sp(d2 * (h * w) + x2 * w + y2) = costNew
            heap.add(d2 * (h * w) + x2 * w + y2, costNew)
          } else if (costNew < costOld) {
            sp(d2 * (h * w) + x2 * w + y2) = costNew
            heap.upPriority(d2 * (h * w) + x2 * w + y2, costNew)
          }
        }
      }
    }
    sp
  }

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

    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 = {
      indexMap += heap(i)._1 -> j
      indexMap += heap(j)._1 -> i

      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)
        indexMap += a -> (size - 1)
        upHeap(size - 1)
      }
    }

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

    def upPriority(a: A, p: P): Unit = {
      val idx = indexMap(a)
      heap(idx) = (a, p)
      upHeap(idx)
    }
  }

  val sp = shortestPath(x1, y1)
  val ans = (0 until 4).map{ d =>
    val ab = sp(d * (h * w) + x2 * w + y2)
    val a = ab / m
    val b = ab % m
    a + (if (b == 0) 0 else 1)
  }.min
  println(ans)
}
