using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using static System.Console;

class Program
{
    static void Main(string[] args)
    {
        var HW = ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();
        var (H, W) = (HW[0], HW[1]);
        var C = ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();
        var D = ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();
        var S = new bool[H][];
        for (int i = 0; i < H; i++)
            S[i] = ReadLine().Select(c => c == '.').ToArray();

        var blockCount = 0;
        var map = new int[H][];
        for (int i = 0; i < H; i++)
            map[i] = S[i].Select(x => x ? 0 : -1).ToArray();

        for (int i = 0; i < H; i++)
        {
            for (int j = 0; j < W; j++)
            {
                if (map[i][j] != 0)
                    continue;

                blockCount++;

                var q = new Queue<(int y, int x)>();

                map[i][j] = blockCount;
                q.Enqueue((i, j));

                while (0 < q.Count)
                {
                    var (y, x) = q.Dequeue();

                    static (int y, int x) Next(int y, int x) => (x, -y);
                    var (dy, dx) = (0, 1);
                    foreach(var p in Enumerable.Range(0, 4).Select(i => (dy, dx) = Next(dy, dx)).Select(d => (y: y + d.dy, x: x + d.dx)).Where(p => 0 <= p.y && p.y < H && 0 <= p.x && p.x < W))
                    {
                        if (map[p.y][p.x] == 0)
                        {
                            map[p.y][p.x] = blockCount;
                            q.Enqueue(p);
                        }
                    }
                }
            }
        }

        var ans = GetAns(H, W, C, D, blockCount, map);

        if (ans == int.MaxValue)
            ans = -1;

        WriteLine(ans);
    }

    private static int GetAns(int H, int W, int[] C, int[] D, int blockCount, int[][] map)
    {
        var adjacencyList = new HashSet<int>[blockCount + 1];
        for (int i = 0; i < adjacencyList.Length; i++)
            adjacencyList[i] = new HashSet<int>();

        for (int i = 0; i < H; i++)
        {
            for (int j = 0; j < W; j++)
            {
                if (map[i][j] == -1)
                    continue;

                for (int _i = i - 2; _i < i + 3; _i++)
                {
                    for (int _j = j - 2; _j < j + 3; _j++)
                    {
                        if (_i < 0 || H <= _i || _j < 0 || W <= _j)
                            continue;
                        if (map[_i][_j] == -1)
                            continue;

                        if (map[i][j] != map[_i][_j])
                        {
                            var a = map[i][j];
                            var b = map[_i][_j];

                            adjacencyList[a].Add(b);
                            adjacencyList[b].Add(a);
                        }
                    }
                }
            }
        }

        var CBlock = map[C[0] - 1][C[1] - 1];
        var DBlock = map[D[0] - 1][D[1] - 1];

        var ans = int.MaxValue;

        var visited = new int[blockCount + 1];
        for (int i = 0; i < visited.Length; i++)
            visited[i] = -1;

        void Bfs(int v)
        {
            var q = new Queue<(int v, int count)>();

            visited[v] = 1;
            q.Enqueue((v, 0));

            while (0 < q.Count)
            {
                var (_v, count) = q.Dequeue();

                if (_v == DBlock)
                    ans = Math.Min(ans, count);

                foreach (var next in adjacencyList[_v])
                {
                    if (visited[next] == -1)
                    {
                        visited[next] = 1;
                        q.Enqueue((next, count + 1));
                    }
                }
            }
        }

        Bfs(CBlock);
        return ans;
    }
}


Measured memory_bytes: 64720