#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

#define M 1000000007
#define FOR(i, s, n) for (ll i = (s); i < (n); ++i)
#define FORALL(i, n) for (ll i = 0; i < (n); ++i)
#define MOD 1000000007
#define ff first
#define ss second
#define pll pair<long long, long long>
#define pii pair<int,int>
#define fast ios_base::sync_with_stdio(false)
#define countbits(x) __builtin_popcount(x)
#define pb(x) push_back((x))
#define vll vector<ll>
#define all(x) x.begin(),x.end()
#define print(x) cout << x << endl
#define debug print("reaching\n")
#define mll map<ll,ll>
#define lsb(i) i&(-i)
#define printv(x) \
	FORALL(i, x.size()) \
	{ \
		cout << x[i] << ' '; \
	} \
	cout << endl \
;
#define input(v,x) \
	FORALL(i,n) \
	{ \
		cin>>v[i]; \
	} \
;
#define printm(m) \
	for(auto i: m){\
		cout<<i.ff<<' '<<i.ss<<endl; \
	}\
;
// vector<map<ll,ll>> m(2);
long long binpow(long long a, long long b) {
	if(b<=0) return 1;
    long long res = 1;
    while (b > 0) {
        if (b & 1)
            res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}

// vll start;
// vll finish;
// vll ft;
// void dfs(vector<vll>& g, ll cur, ll par){
//     static ll timer = 0;
//     ft[timer] = cur;
//     start[cur] = timer;
//     timer++;
//     for(int i = 0; i < g[cur].size(); i++)
//         if(g[cur][i] != par)
//             dfs(g, g[cur][i], cur);
//     finish[cur] = timer;
//     ft[timer] = cur;
//     timer++;
// }

// node st[4*(1000001)];
// int lazy[4*(1000001)];

// void build(int si, int ss, int se){
// 	if(ss == se){
// 		st[si].a[0] = 1;
// 		st[si].a[1] = 0;
// 		st[si].a[2] = 0;
// 		return;
// 	}
// 	int mid = (ss+se)/2;
// 	build(2*si, ss, mid);
// 	build(2*si + 1, mid+1,se);
// 	st[si].a[0] = st[2*si].a[0] + st[2*si + 1].a[0];
// 	st[si].a[1] = st[2*si].a[1] + st[2*si + 1].a[1];
// 	st[si].a[2] = st[2*si].a[2] + st[2*si + 1].a[2];
// }

// void update(int si, int ss, int se, int qs, int qe){
// 	if(lazy[si]!= 0){
// 		int add = lazy[si];
// 		lazy[si]%=3;
// 		FORALL(i,lazy[si]){
// 			swap(st[si].a[0], st[si].a[1]);
// 			swap(st[si].a[0], st[si].a[2]);
// 		}
// 		if(ss!=se){
// 			lazy[2*si] += add;
// 			lazy[2*si+1] += add;
// 		}
// 		lazy[si] = 0;
// 	}
// 	if(ss>qe or qs>se) return;
// 	if(ss>=qs and qe>=se){
// 		swap(st[si].a[0], st[si].a[1]);
// 		swap(st[si].a[0], st[si].a[2]);
// 		if(ss!=se){
// 			lazy[2*si]++;
// 			lazy[2*si+1]++;
// 		}
// 		return;
// 	}
// 	int mid = (ss + se)/2;
// 	update(2*si, ss, mid, qs, qe);
// 	update(2*si+1, mid+1, se, qs, qe);
// 	st[si].a[0] = st[2*si].a[0] + st[2*si + 1].a[0];
// 	st[si].a[1] = st[2*si].a[1] + st[2*si + 1].a[1];
// 	st[si].a[2] = st[2*si].a[2] + st[2*si + 1].a[2];
// }

// int get(int si, int ss, int se, int qs, int qe){
// 	if(lazy[si]!= 0){
// 		int add = lazy[si];
// 		lazy[si]%=3;
// 		FORALL(i,lazy[si]){
// 			swap(st[si].a[0], st[si].a[1]);
// 			swap(st[si].a[0], st[si].a[2]);
// 		}
// 		if(ss!=se){
// 			lazy[2*si] += add;
// 			lazy[2*si+1] += add;
// 		}
// 		lazy[si] = 0;
// 	}
// 	if(ss>qe or qs>se) return 0;
// 	if(ss>=qs and qe>=se){
// 		return st[si].a[0];
// 	}
// 	int mid = (ss + se)/2;
// 	int left = get(2*si, ss, mid, qs, qe);
// 	int right = get(2*si+1, mid+1, se, qs, qe);
// 	return left + right;
// }


template <typename T>
T extGcd(T a, T b, T &x, T &y)
{
	if (b == 0)
	{
		x = 1;
		y = 0;
		return a;
	}
	else
	{
		int g = extGcd(b, a % b, y, x);
		y -= a / b * x;
		return g;
	}
}

template <typename T>
T modInv(T a, T m)
{
	T x, y;
	extGcd(a, m, x, y);
	return (x % m + m) % m;
}

// ll fac[1000005];
// ll ifac[1000005];
// void temp(){
// 		fac[0] = fac[1] = 1;
// 		ifac[0] = ifac[1] = 1;
// 		for(int i=1;i< 1000005;i++){
// 			fac[i] = (fac[i-1]%MOD)*(i%MOD);
// 			fac[i] += MOD;
// 			fac[i]%=MOD;
// 			ifac[i] = (ifac[i-1]%MOD)*(modInv(i, MOD)%MOD);
// 			ifac[i] += MOD;
// 			ifac[i]%=MOD;
// 		}
// }
// ll cc(int n, int r){
// 	if(n==0) return 0;
// 	if(n==1) return 1;
// 	ll ans = (fac[n] * ifac[n-r])%MOD;
// 	ans = ans * ifac[r];
// 	ans%=MOD;
// 	return ans;
// }


bool safe(int x, int y, int n, int m){
	if(x>=0 and y>=0 and x<n and y<m) return true;
	else return false;
}
int main()
{
	fast;
	cin.tie(0);
	cout.tie(0);
	// #ifndef ONLINE_JUDGE
	// freopen("input.txt", "r", stdin);
	// freopen("output.txt", "w", stdout);
	// #endif

	int t=1;
	// cin>>t;
	ll tot=t;
	while(t--){
		ll n,m;
		cin>>n>>m;
		ll a[2];
		cin>>a[0]>>a[1];
		ll b[2];
		cin>>b[0]>>b[1];
		char mat[n][m];
		int vis[n][m];
		FORALL(i,n){
			FORALL(j,m){
				cin>>mat[i][j];
				vis[i][j] = 0;
			}
		}
		deque<pair<pii,int>> q;
		int r[4] = {0, -1,1,0};
		int c[4] = {1, 0, 0, -1};
		q.push_front({{a[0]-1, a[1]-1}, 0});
		// map<pii, int> vis;
		
		while(q.size()){
			pair<pii,int> x = q.front();
			q.pop_front();
			if(vis[x.ff.ff][x.ff.ss]){
				continue;
			}
			vis[x.ff.ff][x.ff.ss] = 1;
			// cout<<x.ff.ff<<' '<<x.ff.ss<<endl;
			if(x.ff.ff == b[0]-1 and x.ff.ss == b[1]-1){
				cout<<x.ss<<'\n';
				return 0;
			}
			FORALL(i,4){
				if(safe(x.ff.ff + r[i], x.ff.ss + c[i], n, m)){
					int nx = x.ff.ff + r[i];
					int ny = x.ff.ss + c[i];
					if(nx == b[0]-1 and ny == b[1]-1){
						print(x.ss);
						return 0;
					}
					if(vis[nx][ny]) continue;
					if(mat[nx][ny]=='.'){
						q.push_front({{nx,ny}, x.ss});
						// vis[{nx,ny}] = 1;
						continue;
					}
					for(int j = x.ff.ff - 2; j <= x.ff.ff + 2; j++){
						for(int k = x.ff.ss - 2; k <= x.ff.ss + 2; k++){
							if(!safe(j,k,n,m)) continue;
							if(vis[j][k]) continue;
							if(j==x.ff.ff and k == x.ff.ss) continue;
							if(mat[j][k]=='.'){
								// if(j == b[0]-1 and k == b[1]-1){
								// 	print(x.ss + 1);
								// 	return 0;
								// }
								q.push_back({{j,k}, x.ss + 1});
								// vis[{j,k}] = 1;
							}
						}
					}
				}
			}
		}
		print(-1);
	}
	return 0;
}
		// string s;
		// cin>>s;
		// int last = -1;
		// int ans = 0;
		// int n = s.length();
		// int dp[n][2];
		// memset(dp, 0, sizeof(dp));
		// for(int i =0; i<n;i++){
		// 	if(s[i]==s[(i-1+n)%n]){
		// 		dp[i][1] = (1 + dp[(i-1+n)%n][0]);
		// 		dp[i][0] = dp[(i-1+n)%n][1];
		// 	}
		// 	else{
		// 		dp[i][1] = dp[(i-1+n)%n][1] + 1;
		// 		dp[i][0] = dp[(i-1+n)%n][0];
		// 	}
		// }
		// // cout<<dp[n-1][0]<<' '<<dp[n-1][1]<<endl;
		// ans = min(dp[n-1][0], dp[n-1][1]);
		// if(n!=2 and dp[n-1][1]<=dp[n-1][0] and s[0]==s[n-1]){
		// 	ans--;
		// }
		// print(ans);

Measured memory_bytes: 9480