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

#define NDEBUG
#include <cassert>


typedef long long ll;
typedef long double Double;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef pair<ll, ll> llll;
typedef pair<double, double> dd;

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<llll> vllll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<long double> vD;

#define sz(a) int((a).size())
#define pb push_back
#define eb emplace_back
#define FOR(var, from, to) for (int var = (from); var <= (to); ++var)
#define rep(var, n) for (int var = 0; var < (n); ++var)
#define rep1(var, n) for (int var = 1; var <= (n); ++var)
#define repC2(vari, varj, n)                 \
    for (int vari = 0; vari < (n)-1; ++vari) \
        for (int varj = vari + 1; varj < (n); ++varj)
#define repC3(vari, varj, vark, n)                      \
    for (int vari = 0; vari < (n)-2; ++vari)            \
        for (int varj = vari + 1; varj < (n)-1; ++varj) \
            for (int vark = varj + 1; vark < (n); ++vark)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define tr(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define found(s, e) ((s).find(e) != (s).end())
#define mset(arr, val) memset(arr, val, sizeof(arr))
#define mid(x, y) ((x) + ((y) - (x)) / 2)
#define IN(x, a, b) ((a) <= (x) && (x) <= (b))
#define cons make_pair
#define clamp(v, lo, hi) min(max(v, lo), hi)
#define ABS(x) max((x), -(x))
#define PQ(T) priority_queue<T, vector<T>, greater<T>>

template <typename T1, typename T2>
inline void amin(T1& a, T2 const& b) {
    if (a > b) a = b;
}
template <typename T1, typename T2>
inline void amax(T1& a, T2 const& b) {
    if (a < b) a = b;
}
template <typename X, typename T>
auto vectors(X x, T a) {
    return vector<T>(x, a);
}
template <typename X, typename Y, typename Z, typename... Zs>
auto vectors(X x, Y y, Z z, Zs... zs) {
    auto cont = vectors(y, z, zs...);
    return vector<decltype(cont)>(x, cont);
}

inline ll square(ll x) { return x * x; }
inline ll gcd(ll a, ll b) {
    while (a) swap(a, b %= a);
    return b;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <typename T>
inline T mod(T a, T b) {
    return ((a % b) + b) % b;
}

template <typename T>
int find_left(vector<T>& v, T elem) {
    return (int)(upper_bound(v.begin(), v.end(), elem) - v.begin()) - 1;
}
template <typename T>
int find_right(vector<T>& v, T elem) {
    return (int)(lower_bound(v.begin(), v.end(), elem) - v.begin());
}

const ll MOD = 1000000007LL;

inline ll ADD(ll x, ll y) { return (x + y) % MOD; }
inline ll SUB(ll x, ll y) { return (x - y + MOD) % MOD; }
inline ll MUL(ll x, ll y) { return x * y % MOD; }
inline ll POW(ll x, ll e) {
    ll v = 1;
    for (; e; x = MUL(x, x), e >>= 1)
        if (e & 1) v = MUL(v, x);
    return v;
}
inline ll INV(ll y) { /*assert(y%MOD!=0);*/
    return POW(y, MOD - 2);
}
inline ll DIV(ll x, ll y) { return MUL(x, INV(y)); }

#define INTSPACE 12
char _buf[INTSPACE * 1000000 + 3];

int loadint() {
    if (fgets(_buf, INTSPACE + 3, stdin) == NULL) return 0;
    return atoi(_buf);
}

int loadvec(vector<int>& v, int N = -1) {
    if (N == 0) {
        v.clear();
        return 0;
    }
    if (N == -1) {
        N = loadint();
        if (N == 0) return 0;
    }
    int bufsize = INTSPACE * N + 3;
    if (fgets(_buf, bufsize, stdin) == NULL) return 0;
    v.resize(N);

    int i = 0;
    bool last = false;
    for (char* p = &_buf[0];;) {
        char* q = p;
        while (*q > ' ') ++q;
        if (*q == 0x0D || *q == 0x0A) last = true;
        *q = 0;
        v[i++] = atoi(p);
        if (last || i == N) break;
        p = q + 1;
    }
    return i;
}
void read_cr() { fgets(_buf, 256, stdin); }

void horizontal(vector<int>& v) {
    int L = v.size();
    for (int i = 0; i < L; ++i) {
        printf("%d%c", v[i], (i == L - 1) ? '\n' : ' ');
    }
}
void horizontall(vector<long long>& v) {
    int L = v.size();
    for (int i = 0; i < L; ++i) {
        printf("%lld%c", v[i], (i == L - 1) ? '\n' : ' ');
    }
}

class UnionFind2D {
   public:
    vector<int> data;
    int height, width;
    int count;
    inline int RC(int r, int c) { return r * width + c; }
    inline bool inside(int r, int c) { return (0 <= r && r < height && 0 <= c && c < width); }

   public:
    UnionFind2D(int height, int width) : data(height * width, -1), height(height), width(width), count(height * width) {}

    bool unionSet(int x, int y) {
        x = root(x);
        y = root(y);
        if (x != y) {
            if (data[y] < data[x]) swap(x, y);
            data[x] += data[y];
            data[y] = x;
            --count;
        }
        return x != y;
    }
    bool isSame(int x, int y) { return root(x) == root(y); }
    int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
    int size(int x) { return -data[root(x)]; }

    bool unionSet(int r0, int c0, int r1, int c1) {
        if (!inside(r0, c0) || !inside(r1, c1)) return false;
        return unionSet(RC(r0, c0), RC(r1, c1));
    }
    bool isSame(int r0, int c0, int r1, int c1) {
        if (!inside(r0, c0) || !inside(r1, c1)) return false;
        return root(r0, c0) == root(r1, c1);
    }
    int root(int r, int c) {
        if (!inside(r, c)) return -1;
        return root(RC(r, c));
    }
    int size(int r, int c) {
        if (!inside(r, c)) return 0;
        return size(RC(r, c));
    }

    bool unionSet(pair<int, int>& p0, pair<int, int>& p1) { return unionSet(p0.first, p0.second, p1.first, p1.second); }
    bool isSame(pair<int, int>& p0, pair<int, int>& p1) {
        return isSame(p0.first, p0.second, p1.first, p1.second);
    }
    int root(pair<int, int>& p) { return root(p.first, p.second); }
    int size(pair<int, int>& p) { return size(p.first, p.second); }
};

const int INF = 9999999;

template <typename T>
void make_adjacent(int nV, vector<pair<ii, T>>& arcs, vector<vector<pair<int, T>>>& adj) {
    adj.resize(nV);
    for (pair<ii, T> p : arcs) {
        int u = p.first.first, v = p.first.second;
        assert(u != v);
        T distance = p.second;
        adj[u].push_back(make_pair(v, distance));
        adj[v].push_back(make_pair(u, distance));
    }
}

template <typename T>
void dij1(int nV, vector<vector<pair<int, T>>>& adjacent, vector<T>& d, int start) {
    d.assign(nV, INF);
    d[start] = 0;
    vector<int> prev(nV, -1);

    priority_queue<pair<T, int>> Q;
    Q.push(make_pair(0, start));

    vector<bool> visited(nV, false);

    while (!Q.empty()) {
        T du = -Q.top().first;
        int u = Q.top().second;
        Q.pop();
        if (visited[u]) continue;
        visited[u] = true;

        int c = adjacent[u].size();
        for (int i = 0; i < c; ++i) {
            int v = adjacent[u][i].first;
            T distance = adjacent[u][i].second;
            T alt = du + distance;
            if (d[v] > alt) {
                d[v] = alt;
                prev[v] = u;
                Q.push(make_pair(-alt, v));
            }
        }
    }
}

template <typename T>
void dij(int nV, vector<vector<pair<int, T>>>& adjacent, vector<vector<T>>& d) {
    d.resize(nV);
    for (int start = 0; start < nV; ++start) {
        dij1(nV, adjacent, d[start], start);
    }
}

int solve(int H, int W, int Ch, int Cw, int Dh, int Dw, vs& s) {
    --Ch;
    --Cw;
    --Dh;
    --Dw;
    UnionFind2D uf(H, W);
    rep(r, H) rep(c, W) {
        if (s[r][c] == '#') continue;

        if (0 <= r - 1 && s[r - 1][c] == '.') {
            uf.unionSet(r, c, r - 1, c);
        }
        if (r + 1 < H && s[r + 1][c] == '.') {
            uf.unionSet(r, c, r + 1, c);
        }
        if (0 <= c - 1 && s[r][c - 1] == '.') {
            uf.unionSet(r, c, r, c - 1);
        }
        if (c + 1 < W && s[r][c + 1] == '.') {
            uf.unionSet(r, c, r, c + 1);
        }
    }
    int start = uf.root(Ch, Cw), goal = uf.root(Dh, Dw);

    int nV = H * W;
    vector<vii> adj(nV);

    rep(r, H) rep(c, W) {
        if (s[r][c] == '#') continue;
        int root0 = uf.root(r, c);
        for (int y = -2; y <= 2; ++y) {
            for (int x = -2; x <= 2; ++x) {
                if (x == 0 && y == 0) continue;
                int r1 = r + y, c1 = c + x;
                if (IN(r1, 0, H - 1) && IN(c1, 0, W - 1) && s[r1][c1] == '.') {
                    int root1 = uf.root(r1, c1);
                    if (root0 < root1) {
                        adj[root0].eb(root1, 1);
                        adj[root1].eb(root0, 1);
                    }
                }
            }
        }
    }
    vi d(nV, INF);
    dij1(nV, adj, d, start);
    int ans = d[goal];
    if (ans >= INF) return -1;
    return ans;
}

int main() {
    int H, W;
    cin >> H >> W;
    int Ch, Cw;
    cin >> Ch >> Cw;
    int Dh, Dw;
    cin >> Dh >> Dw;
    vs s(H);
    rep(i, H) cin >> s[i];
    cout << solve(H, W, Ch, Cw, Dh, Dw, s) << endl;
    return 0;
}


Measured memory_bytes: 62224