#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;

const static int	BIG		= (int)1e9;
const static ll		BIGLL	= (ll)4e18;
const static double	PI = acos(-1);
const static double EPS = 1e-9;
template<class T> T Sq(T a) { return (a)*(a); }
template<class T> T SqSum(T x, T y) { return x * x + y * y; }
template<class T> bool InRange(T x, T a, T b) { return a <= x && x <= b; }
template<class T> void amin(T &a, T v) { if (a > v) a = v; }
template<class T> void amax(T &a, T v) { if (a < v) a = v; }
bool IsInt(double x) { return fabs(round(x) - x) <= EPS; }
bool IsEqual(double x, double y) { return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y))); }

template<class T>
vector<T> make_vector(int n, T t) {
	return vector<T>(n, t);
}

template<class ...Ts>
auto make_vector(int n, Ts ... ts) {
	return vector<decltype(make_vector(ts...))>(n, make_vector(ts...));
}

#define SZ(a) ((int)(a).size())
#define ARRAY_NUM(a) (sizeof(a)/sizeof(a[0])) 
#define NG (-1)

#define REP(i,n) for(ll i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()

#define YES(n) cout << ((n) ? "YES" : "NO"  ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No"  ) << endl
#define POSSIBLE(n) cout << ((n) ? "POSSIBLE" : "IMPOSSIBLE"  ) << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible"  ) << endl

#define BitSet(arg,posn) ((arg) |= (1LL << (posn)))
#define BitClr(arg,posn) ((arg) &= ~(1LL << (posn)))
#define BitFlp(arg,posn) ((arg) ^= (1LL << (posn)))
#define IsBit(arg,posn) static_cast<bool>((arg) & (1LL << (posn)))

#define Print(x) cerr<<#x<<": "<<(x)<<endl
#define PrintVec(v) cerr<<#v<<": ";REP(__i,(v).size())cerr<<((v)[__i])<<", ";cerr<<endl


struct in {
	int n;
	in() {}
	in(int n_) : n(n_) {};
	template <class T> operator T() {
		T ret;
		cin >> ret;
		return ret;
	}
	template <class T> operator vector<T>() {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) cin >> ret[i];
		return ret;
	}
};

// modint: mod 計算を int を扱うように扱える構造体
template<int MOD>
struct ModInt {
	long long val;
	constexpr ModInt(long long v = 0) noexcept : val(v % MOD) {
		if (val < 0) v += MOD;
	}
	constexpr int getmod() { return MOD; }
	constexpr ModInt operator - () const noexcept {
		return val ? MOD - val : 0;
	}
	constexpr ModInt operator + (const ModInt& r) const noexcept { return ModInt(*this) += r; }
	constexpr ModInt operator - (const ModInt& r) const noexcept { return ModInt(*this) -= r; }
	constexpr ModInt operator * (const ModInt& r) const noexcept { return ModInt(*this) *= r; }
	constexpr ModInt operator / (const ModInt& r) const noexcept { return ModInt(*this) /= r; }
	constexpr ModInt& operator += (const ModInt& r) noexcept {
		val += r.val;
		if (val >= MOD) val -= MOD;
		return *this;
	}
	constexpr ModInt& operator -= (const ModInt& r) noexcept {
		val -= r.val;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr ModInt& operator *= (const ModInt& r) noexcept {
		val = val * r.val % MOD;
		return *this;
	}
	constexpr ModInt& operator /= (const ModInt& r) noexcept {
		long long a = r.val, b = MOD, u = 1, v = 0;
		while (b) {
			long long t = a / b;
			a -= t * b; swap(a, b);
			u -= t * v; swap(u, v);
		}
		val = val * u % MOD;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr bool operator == (const ModInt& r) const noexcept {
		return this->val == r.val;
	}
	constexpr bool operator != (const ModInt& r) const noexcept {
		return this->val != r.val;
	}

	friend ostream& operator << (ostream &os, const ModInt<MOD>& x) noexcept {
		return os << x.val;
	}
	friend istream& operator >> (istream &is, ModInt<MOD>& x) noexcept {
		return is >> x.val;
	}
	
	// mint ret = modpow((mint)2, i); のように直接呼べます。
	friend constexpr ModInt<MOD> modpow(const ModInt<MOD> &a, long long n) noexcept {
		if (n == 0) return 1;
		auto t = modpow(a, n / 2);
		t = t * t;
		if (n & 1) t = t * a;
		return t;
	}
};

// 二項係数ライブラリ
template<class T> struct BiCoef
{
	constexpr BiCoef() {}
	constexpr BiCoef(int n) noexcept : mFact(n, 1), mInv(n, 1), mFInv(n, 1)
	{
		Init(n);
	}

	constexpr void Init(int n) noexcept
	{
		mFact.assign(n, 1), mInv.assign(n, 1), mFInv.assign(n, 1);
		int factMod = mFact[0].getmod();
		for (int i = 2; i < n; i++) {
			mFact[i] = mFact[i - 1] * i;
			mInv[i] = -mInv[factMod%i] * (factMod / i);
			mFInv[i] = mFInv[i - 1] * mInv[i];
		}
	}

	constexpr T Fact(int n) const noexcept {
		if (n < 0) return 0;
		return mFact[n];
	}

	constexpr T Comb(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[k] * mFInv[n - k];
	}

	constexpr T Perm(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[n - k];
	}

	constexpr T Homo(int n, int r) const {
		if (n < 0 || r < 0) return 0;
		return r == 0 ? 1 : Comb(n + r - 1, r);
	}

	constexpr T inv(int n) const noexcept {
		if (n < 0) return 0;
		return mInv[n];
	}

	constexpr T finv(int n) const noexcept {
		if (n < 0) return 0;
		return mFInv[n];
	}

	vector<T> mFact;
	vector<T> mInv;
	vector<T> mFInv;
};

const int MOD = 1000000007;
using mint = ModInt<MOD>;
// BiCoef<mint> bc(8*1024*1024); // 8M * 3 * 8B(ll) = 192MB (0.5sec)


// ダイクストラ法（ここから）
template< typename T >
struct Edge {
    int from, to;
    T cost;

    Edge() {}
    Edge(int to, T cost) : from(-1), to(to), cost(cost) {}
    Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};

template< typename T > using Edges = vector< Edge< T > >;
template< typename T > using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T > using Matrix = vector< vector< T > >;



// ダイクストラ法
// output
// - dist 
// - prev 直前の頂点
template< typename T >
void dijkstra(vector <T>& dist, vector <int>& prev, const int start, const WeightedGraph<T>& adj)
{
    const int V = SZ(adj);
    const auto INF = BIG; // numeric_limits< T >::max();
    dist = vector <T>(V, INF);
    prev = vector <int>(V, NG);
    dist[start] = 0;

    priority_queue<pair<T, int>, vector< pair<T, int> >, greater< pair<T, int> > > pq;
    pq.push(pair<T, int>(0, start));

    while (!pq.empty())
    {
        pair<T, int> top = pq.top();
        pq.pop();

        const T d = top.first;
        const int v1 = top.second;
        if (d <= dist[v1])
        {
            for (const auto& e : adj[v1])
            {
                int v2 = e.to;
                T cost = e.cost;
                if (dist[v2] > dist[v1] + cost)
                {
                    dist[v2] = dist[v1] + cost;
                    prev[v2] = v1;
                    pq.emplace(pair<T, int>(dist[v2], v2));
                }
            }
        }
    }
}

int main()
{
    ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);cout << fixed << setprecision(15);

    int H, W;
    cin >> H >> W;

    const int V = H*W;

    WeightedGraph<int> adj(V);


    int ch, cw;
    cin >> ch >> cw;
    ch--;
    cw--;
    const int cv = ch*W+cw;

    ll dh, dw;
    cin >> dh >> dw;
    dh--;
    dw--;
    const int dv = dh * W + dw;

    vector <string> vs;
    for (int y = 0; y < H; ++y)
    {
        string s;
        cin >> s;
        vs.push_back(s);
    }

    for (int y = 0; y < H; ++y)
    {
        for (int x = 0; x < W; ++x)
        {
            if(vs[y][x]=='#') continue;

            const static int dy[] = { -1, 0, 1, 0 }; // U,R,D,L
            const static int dx[] = { 0, 1, 0,-1 };
            const int v = y*W+x;
            for (int d = 0; d < 4; ++d)
            {
                const int ny = y + dy[d];
                const int nx = x + dx[d];
                const int nv = ny*W+nx;
                if (InRange(ny, 0, SZ(vs) - 1) && InRange(nx, 0, SZ(vs[y]) - 1) && vs[ny][nx] != '#')
                {
                    adj[v].emplace_back(v, nv, 0);
                }
            }

            for (int ddy = -2; ddy <= 2; ddy++)
            {
                for (int ddx = -2; ddx <= 2; ddx++)
                {
                    const int ny = y + ddy;
                    const int nx = x + ddx;
                    const int nv = ny * W + nx;
                    if (InRange(ny, 0, SZ(vs) - 1) && InRange(nx, 0, SZ(vs[y]) - 1) && vs[ny][nx] != '#')
                    {
                        adj[v].emplace_back(v, nv, 1);
                    }
                }
            }
        }
    }

    vector <int> dist;
    vector <int> prev;

    dijkstra(dist, prev, cv, adj);
    if (dist[dv] >= BIG)
    {
        cout << -1 << endl;
    }
    else
    {
        cout << dist[dv] << endl;
    }




	return 0;
}


Measured memory_bytes: 165324