import java.util.*
import kotlin.math.min

fun intList() = readLine()?.split(" ")?.map(String::toInt) ?: TODO()
fun main() {
    val (h, w) = intList()
    val (ch, cw) = intList()
    val (dh, dw) = intList()
    val maze = mutableListOf<String>()
    repeat(h) {
        val s = readLine() ?: return
        maze.add(s)
    }
    var magicCount = Int.MAX_VALUE

    data class NextStep(val y: Int, val x: Int, val magicCount: Int) : Comparable<NextStep> {
        override fun compareTo(other: NextStep): Int {
            return this.magicCount - other.magicCount
        }
    }

    val explored = Array(h) { Array(w) { Int.MAX_VALUE } }
    val queue = PriorityQueue<NextStep>()

    queue.offer(NextStep(ch - 1, cw - 1, 0))
    fun warp(y: Int, x: Int, m: Int) {
        if (y >= 0 && y < h && x >= 0 && x < w) {
            if (maze[y][x] != '#' && explored[y][x] > m + 1) {
                queue.offer(NextStep(y, x, m + 1))
            }
        }
    }
    while (queue.isNotEmpty()) {
        val (y, x, m) = queue.poll()
        if (explored[y][x] > m) {
            explored[y][x] = m
            if (y == dh - 1 && x == dw - 1) {
                magicCount = min(magicCount, m)
            } else {
                //上
                if (y - 1 >= 0) {
                    if (maze[y - 1][x] == '#') {
                        warp(y - 2, x, m)
                        warp(y - 2, x - 2, m)
                        warp(y - 2, x - 1, m)
                        warp(y - 2, x + 1, m)
                        warp(y - 2, x + 2, m)
                        warp(y - 1, x - 2, m)
                        warp(y - 1, x - 1, m)
                        warp(y - 1, x + 1, m)
                        warp(y - 1, x + 2, m)
                    } else {
                        if (explored[y - 1][x] > m) {
                            queue.offer(NextStep(y - 1, x, m))
                        }
                    }
                }
                //下
                if (y + 1 < h) {
                    if (maze[y + 1][x] == '#') {
                        warp(y + 2, x, m)
                        warp(y + 2, x - 2, m)
                        warp(y + 2, x - 1, m)
                        warp(y + 2, x + 1, m)
                        warp(y + 2, x + 2, m)
                        warp(y + 1, x - 2, m)
                        warp(y + 1, x - 1, m)
                        warp(y + 1, x + 1, m)
                        warp(y + 1, x + 2, m)
                    } else {
                        if (explored[y + 1][x] > m) {
                            queue.offer(NextStep(y + 1, x, m))
                        }
                    }
                }
                //左
                if (x - 1 >= 0) {
                    if (maze[y][x - 1] == '#') {
                        warp(y, x - 2, m)
                    } else {
                        if (explored[y][x - 1] > m) {
                            queue.offer(NextStep(y, x - 1, m))
                        }
                    }
                }
                //右
                if (x + 1 < w) {
                    if (maze[y][x + 1] == '#') {
                        warp(y, x + 2, m)
                    } else {
                        if (explored[y][x + 1] > m) {
                            queue.offer(NextStep(y, x + 1, m))
                        }
                    }
                }
            }
        }
    }
    if (magicCount == Int.MAX_VALUE) {
        println("-1")
    } else {
        println(magicCount.toString())
    }
}


Measured memory_bytes: 89948