using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		string[] str = Console.ReadLine().Split();
		int H = int.Parse(str[0]);
		int W = int.Parse(str[1]);
		string[] str1 = Console.ReadLine().Split();
		int H1 = int.Parse(str1[0]);
		int W1 = int.Parse(str1[1]);
		string[] str1B = Console.ReadLine().Split();
		int H2 = int.Parse(str1B[0]);
		int W2 = int.Parse(str1B[1]);
		int[,]A = new int[H,W];
		for(var i=0;i<H;i++){
			string str2 = Console.ReadLine();
			for(var j=0;j<W;j++){
				if(str2.Substring(j,1)=="#"){
					A[i,j]=1;
				}
			}
		}
		int[,]D = new int[H,W];
		for(var i=0;i<H;i++){
			for(var j=0;j<W;j++){
				D[i,j] = 999999;
			}
		}
		D[H1-1,W1-1] = 0;
		var list = new PriorityQueue<int>((x,y)=>(D[x/W,x%W]-D[y/W,y%W]));
		list.Enqueue((H1-1)*W+W1-1);
		while(list.Count>0){
			var q = list.Dequeue();
          	//Console.Error.WriteLine(q);
			var x = q/W;
			var y = q%W;
			if(x>0 && A[x-1,y]==0 && D[x-1,y]>D[x,y]){
				D[x-1,y] = D[x,y];
				list.Enqueue((x-1)*W+y);
			}
			if(x<H-1 && A[x+1,y]==0 && D[x+1,y]>D[x,y]){
				D[x+1,y] = D[x,y];
				list.Enqueue((x+1)*W+y);
			}
			if(y>0 && A[x,y-1]==0 && D[x,y-1]>D[x,y]){
				D[x,y-1] = D[x,y];
				list.Enqueue(x*W+y-1);
			}
			if(y<W-1 && A[x,y+1]==0 && D[x,y+1]>D[x,y]){
				D[x,y+1] = D[x,y];
				list.Enqueue(x*W+y+1);
			}
			for(var i=Math.Max(0,x-2);i<=Math.Min(H-1,x+2);i++){
				for(var j=Math.Max(0,y-2);j<=Math.Min(W-1,y+2);j++){
					if(A[i,j]==0 && D[i,j]>D[x,y]+1){
						D[i,j] = D[x,y]+1;
						list.Enqueue(i*W+j);
					}
				}
			}
		}
		if(D[H2-1,W2-1]==999999){
          Console.WriteLine("-1");
        } else {
			Console.WriteLine(D[H2-1,W2-1]);
        }
	}
}

class PriorityQueue<T>
{
    private readonly List<T> heap;
    private readonly Comparison<T> compare;
    private int size;
    public PriorityQueue() : this(Comparer<T>.Default) {} 
    public PriorityQueue(IComparer<T> comparer) : this(16, comparer.Compare) { }
    public PriorityQueue(Comparison<T> comparison) : this(16, comparison) { }
    public PriorityQueue(int capacity, Comparison<T> comparison)
    {
        this.heap = new List<T>(capacity);
        this.compare = comparison;
    }
    public void Enqueue(T item)
    {
        this.heap.Add(item);
        var i = size++;
        while (i > 0)
        {
            var p = (i - 1) >> 1;
            if (compare(this.heap[p], item) <= 0)
                break;
            this.heap[i] = heap[p];
            i = p;
        }
        this.heap[i] = item;

    }
    public T Dequeue()
    {
        var ret = this.heap[0];
        var x = this.heap[--size];
        var i = 0;
        while ((i << 1) + 1 < size)
        {
            var a = (i << 1) + 1;
            var b = (i << 1) + 2;
            if (b < size && compare(heap[b], heap[a]) < 0) a = b;
            if (compare(heap[a], x) >= 0)
                break;
            heap[i] = heap[a];
            i = a;
        }
        heap[i] = x;
        heap.RemoveAt(size);
        return ret;
    }
    public T Peek() { return heap[0]; }
    public int Count { get { return size; } }
    public bool Any() { return size > 0; }
}

Measured memory_bytes: 29308