// ---------- begin input macro ----------
// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, bytes) => {
        read_value!($iter, String).bytes().collect::<Vec<u8>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
// ---------- end input macro ----------

// 最短経路が2以上あるなら2*dが答え
// 到達不可能なら-1
// 最短経路が1つのみの時
// 脇道があったりすれば2*d+2
// 無い時
// 迂回路を探さねばならん
// これもBFSでいい...?
// ダメ
// #####
// #ST.#
// ##.##
// #####
// とか、6手で交換できるけど迂回路がなくて検知できない
// #######################
// #ST...................#
// ####################.##
// #######################
// みたいなのとかもできる
//
// ###################
// #S................#
// #T###############.#
// #.................#
// ###################
// 迂回させるパターンはこれ
//
// 交換不可能は
// 連結でないorグラフがパスである時
// それ以外はできるはず
// 最小コストはどうするのか
// 最短路が2つ以上あるなら明らか
// 1つの時
// 迂回させるパターンか、どこかで入れ替えさせるパターン
// 迂回させるパターンは頑張ってBFS
// 入れ替えさせるパターン
// 到達可能な三叉路を全部試せばいい？

const INF: usize = 1_000_000_000;

fn bfs(src: (usize, usize), s: &[Vec<u8>]) -> Vec<Vec<(usize, usize, usize, usize)>> {
    let h = s.len();
    let w = s[0].len();
    let mut dp = vec![vec![(INF, 0, 0, 0); w]; h];
    dp[src.0][src.1] = (0, 1, 0, 0);
    let mut q = std::collections::VecDeque::new();
    q.push_back(src);
    while let Some((x, y)) = q.pop_front() {
        let (d, way, _, _) = dp[x][y];
        let d = d + 1;
        for &(nx, ny) in [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)].iter() {
            if s[nx][ny] == b'#' {
                continue;
            }
            if dp[nx][ny].0 > d {
                dp[nx][ny] = (d, way, x, y);
                q.push_back((nx, ny));
            } else if dp[nx][ny].0 == d {
                dp[nx][ny].1 = 2;
            }
        }
    }
    dp
}

fn run() {
    input! {
        h: usize,
        w: usize,
        src: (usize1, usize1),
        dst: (usize1, usize1),
        s: [bytes; h],
    }
    let dp_src = bfs(src, &s);
    let dp_dst = bfs(dst, &s);
    let (dis, way, _, _) = dp_src[dst.0][dst.1];
    if dis >= INF {
        println!("-1");
        return;
    } else if way == 2 {
        println!("{}", 2 * dis);
        return;
    }
    let mut ans = INF;
    for i in 1..(h - 1) {
        for j in 1..(w - 1) {
            if dp_src[i][j].0 < INF {
                let mut cnt = 0;
                for p in [(i - 1, j), (i + 1, j), (i, j - 1), (i, j + 1)].iter() {
                    if s[p.0][p.1] == b'.' {
                        cnt += 1;
                    }
                }
                if cnt > 2 {
                    ans = ans.min(2 * dp_src[i][j].0 + 2 * dp_dst[i][j].0 + 4);
                }
            }
        }
    }
    let mut s = s;
    let mut pos = dst;
    while pos != src {
        s[pos.0][pos.1] = b'#';
        let p = dp_src[pos.0][pos.1];
        pos = (p.2, p.3);
    }
    let dp = bfs(src, &s);
    for &p in [(dst.0 - 1, dst.1), (dst.0 + 1, dst.1), (dst.0, dst.1 - 1), (dst.0, dst.1 + 1)].iter() {
        if p != src {
            ans = ans.min(1 + dp[p.0][p.1].0 + dis);
        }
    }
    if ans >= INF {
        println!("-1");
    } else {
        println!("{}", ans);
    }
}

fn main() {
    run();
}