#include <bits/stdc++.h>
 

//tabaicho  see https://boostjp.github.io/tips/multiprec-int.html   
// #include <boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;

// cpp_int
// int128_t
// int256_t
// int512_t
// int1024_t

// uint128_t
// uint256_t
// uint512_t
// uint1024_t



 #define int long long
 #define inf  1000000007
// #define inf  998244353

 #define pa pair<int,int>
 #define ll long long
 #define PI 3.14159265358979323846
 #define  mp make_pair
 #define  pb push_back
 #define EPS (1e-8)
 
      using namespace std;
                                          
 int dx[8]={0,1,0,-1,1,1,-1,-1};
 int dy[8]={1,0,-1,0,-1,1,1,-1};
                                            
class pa3{
	public:
	int x;
	int y,z;
	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
	bool operator < (const pa3 &p) const{
		if(x!=p.x) return x<p.x;
		if(y!=p.y) return y<p.y;
		 return z<p.z;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator > (const pa3 &p) const{
		if(x!=p.x) return x>p.x;
		if(y!=p.y) return y>p.y;
		 return z>p.z;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa3 &p) const{
		return x==p.x && y==p.y && z==p.z;
	}
		bool operator != (const pa3 &p) const{
			return !( x==p.x && y==p.y && z==p.z);
	}

};

class pa4{
	public:
	int x;
	int y,z,w;
	pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
	bool operator < (const pa4 &p) const{
		if(x!=p.x) return x<p.x;
		if(y!=p.y) return y<p.y;
		if(z!=p.z)return z<p.z;
		return w<p.w;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator > (const pa4 &p) const{
		if(x!=p.x) return x>p.x;
		if(y!=p.y) return y>p.y;
		if(z!=p.z)return z>p.z;
		return w>p.w;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa4 &p) const{
		return x==p.x && y==p.y && z==p.z &&w==p.w;
	}
		

};
class pa2{
	public:
	int x,y;
	pa2(int x=0,int y=0):x(x),y(y) {}
	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
	bool operator < (const pa2 &p) const{
		return y != p.y ? y<p.y: x<p.x;
	}
	bool operator > (const pa2 &p) const{
		return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa2 &p) const{
		return abs(x-p.x)==0 && abs(y-p.y)==0;
	}
	bool operator != (const pa2 &p) const{
		return !(abs(x-p.x)==0 && abs(y-p.y)==0);
	}
		

};



string itos( int i ) {
	ostringstream s ;
	s << i ;
	return s.str() ;
}
 
int Gcd(int v,int b){
	if(v==0) return b;
	if(b==0) return v;
	if(v>b) return Gcd(b,v);
	if(v==b) return b;
	if(b%v==0) return v;
	return Gcd(v,b%v);
}


 int mod;
int extgcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = extgcd(b, a%b, y, x);
    y -= a/b * x;
    return d;
}
pa operator+(const pa & l,const pa & r) {   
    return {l.first+r.first,l.second+r.second};                                    
}    
pa operator-(const pa & l,const pa & r) {   
    return {l.first-r.first,l.second-r.second};                                    
}  

ostream& operator<<(ostream& os, const vector<int>& VEC){
	for(auto v:VEC)os<<v<<" ";
    return os;
}

ostream& operator<<(ostream& os, const pa& PAI){
	os<<PAI.first<<" : "<<PAI.second;
    return os;
}

ostream& operator<<(ostream& os, const pa3& PAI){
	os<<PAI.x<<" : "<<PAI.y<<" : "<<PAI.z;
    return os;
}

ostream& operator<<(ostream& os, const pa4& PAI){
	os<<PAI.x<<" : "<<PAI.y<<" : "<<PAI.z<<" : "<<PAI.y;
    return os;
}




int beki(int wa,int rr,int warukazu){
	if(rr==0) return 1%warukazu;
	if(rr==1) return wa%warukazu;
	wa%=warukazu;
	if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;
	ll zx=beki(wa,rr/2,warukazu);
	return (zx*zx)%warukazu;
}

              
int pr[100000];
int inv[100000];



int comb(int nn,int rr){
	if(rr<0 || rr>nn || nn<0) return 0;
	int r=pr[nn]*inv[rr];
	r%=mod;
	r*=inv[nn-rr];
	r%=mod;
	return r;
}

void gya(int ert){
	pr[0]=1;
	for(int i=1;i<=ert;i++){
		pr[i]=((ll)pr[i-1]*i)%mod;
	}
		inv[ert]=beki(pr[ert],mod-2,mod);
	for(int i=ert-1;i>=0;i--){
		inv[i]=(ll)inv[i+1]*(i+1)%mod;
	}
}


                


                
              //   cin.tie(0);
    		//	ios::sync_with_stdio(false);
    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            
                 //sort(ve.begin(),ve.end(),greater<int>());
 //   mt19937(clock_per_sec);
  //  mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
  

struct hoge{
	int a;
	int b;
	bool operator<(const hoge &x)const{return a<x.a;}
	bool operator==(const hoge &x)const{return a==x.a && b==x.b;}
	
	
};
bool operator!=(const hoge &x,const hoge &y){return !(x==y) ;}

struct radix_heap32{

	private:
	public:
	using T=pa;
	
	struct kv{
		int key;
		T val;
	};
	
	
	int sz=0;
	int mn=0;
	
	vector<kv> VEC[33];
	
	
	int msb(int r){
		if(r==0)return 0;
		return 32-__builtin_clz(r);
	}
	
	int size(){
		return sz;
	}
	
	void push(int key,T val){
		assert(mn<=key);
		VEC[msb(mn^key)].pb((kv){key,val});
		sz++;
	}

	kv pop(){
		assert(sz>0);
		if(!VEC[0].size()){
			int it=-1;
			for(int i=1;i<=32;i++)if(VEC[i].size()){
				it=i;
				break;
			}
			assert(it>0);
			int mi=2147483647;
			for(auto v:VEC[it])mi=min(mi,v.key);
			while(VEC[it].size()){
				VEC[msb(mi^VEC[it].back().key)].pb(VEC[it].back());
				VEC[it].pop_back();
			}
		}
		
		
		kv ans=VEC[0].back();
		mn=ans.key;
		sz--;
		VEC[0].pop_back();
		return ans;

	}
	
};

struct radix_heap64{

	private:
	public:
	using T=pa;
	
	struct kv{
		ll key;
		T val;
	};
	
	
	int sz=0;
	ll  mn=0ll;
	
	deque<kv> VEC[65];
	
	
	int msb(ll r){
		if(r==0)return 0;
		return 64-__builtin_clzll((ll)r);
	}
	
	int size(){
		return sz;
	}
	
	
	
	void push(ll key,T val){
		VEC[msb(mn^key)].pb((kv){key,val});
		sz++;
	}
	

	
	kv pop(){
		assert(sz>0);
		if(!VEC[0].size()){
			int it=-1;
			for(int i=1;i<=32;i++)if(VEC[i].size()){
				it=i;
				break;
			}
			ll mi=9223372036854775807ll;
			for(auto v:VEC[it])mi=min(mi,v.key);
			while(VEC[it].size()){
				VEC[msb(mi^VEC[it].back().key)].pb(VEC[it].back());
				VEC[it].pop_back();
			}
		}
		
		
		kv ans=VEC[0].back();
		mn=ans.key;
		sz--;
		VEC[0].pop_back();
		return ans;

	}
	
};



string s[1020];
bool vis[1020][1020]={};
void solve(){
	
	int h,w;
	cin>>h>>w;
	
	int sx,sy;
	cin>>sx>>sy;
	int gx,gy;
	cin>>gx>>gy;
	gx--,gy--;
	sx--,sy--;
	for(int i=0;i<h;i++)cin>>s[i];
 radix_heap64 qu;
//	priority_queue<pa3,vector<pa3>,greater<pa3>> qu;  
			qu.push(0,{sx,sy});
	
	while(qu.size()){
		auto  z=qu.pop();
		if(vis[z.val.first][z.val.second])continue;
		vis[z.val.first][z.val.second]=1;
		if(z.val.first==gx&& z.val.second==gy){
			cout<<z.key<<endl;
			return;
		}
		for(int r=0;r<4;r++){
			int x=z.val.first+dx[r];
			int y=z.val.second+dy[r];
			if(0>x || 0>y || x>=h || y>=w)continue;
			if(vis[x][y])continue;
			if(s[x][y]=='#')continue;
				qu.push(z.key,{x,y});
		}	
		
		for(int i=-2;i<=2;i++)for(int j=-2;j<=2;j++){
			int x=z.val.first+i;
			int y=z.val.second+j;
			if(0>x || 0>y || x>=h || y>=w)continue;
			if(vis[x][y])continue;
			if(s[x][y]=='#')continue;
				qu.push(z.key+1,{x,y});
		}
	}
	
	cout<<-1<<endl;
}
 
signed main(){
	
	cin.tie(0);
	ios::sync_with_stdio(false);
int n=1;
	//cin>>n;
 
	
	for(int i=0;i<n;i++)solve();
	
	return 0;
 }

Measured memory_bytes: 7280