#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <bitset>

long long mod = 1e9+7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a){
    x = a%mod;
    while(x<0){
      x += mod;
    }
  };
  Mint& operator += (const Mint &a){
    x+=a.x;
    x%=mod;
    return *this;
  }
  Mint& operator -= (const Mint &a){
    x += (mod - a.x);
    x%=mod;
    return *this;
  }
  Mint& operator *= (const Mint &a){
    x*=a.x;
    x%=mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const {
    if (n==0) return Mint(1);
    Mint y = pow(n>>1); // pow(n/2)を計算する
    y *= y;
    if (n%2==1) y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const {
    return a.pow(mod-2);
  }

  Mint& operator /= (const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator + (Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator - (Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator * (Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator / (Mint &a) const {
    Mint y(*this);
    y/=a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    Mint one = Mint(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
      y /= (i + one);
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
    }
    return y;
  }
};


int main() {
  int H, W;
  std::cin >> H >> W;
  int Sh, Sw;
  std::cin >> Sh >> Sw;
  Sh--;
  Sw--;
  int Gh, Gw;
  std::cin >> Gh >> Gw;
  Gh--;
  Gw--;
  char map[1004][1004];
  for (int i=0; i<H; i++) {
    std::string s;
    std::cin >> s;
    for (int j=0; j<W; j++) {
      map[i][j] = s[j];
    }
  }
  int magic[1004][1004];
  std::queue<std::pair<int, int> > queue, queue2;
  queue.push(std::make_pair(Sh, Sw));
  magic[Sh][Sw]=0;
  bool use[1004][1004];
  int magicnum = 0;
  for (int i=0; i<1004; i++) {
    for (int j=0; j<1004; j++) {
      magic[i][j] = -1;
      use[i][j] = false;
    }
  }
  int dh[4] = {1, -1, 0, 0};
  int dw[4] = {0, 0, 1, -1};
  while(true) {
    if (queue.size()==0) {
      if (queue2.size()==0) {
        break;
      } else {
        std::swap(queue, queue2);
        magicnum++;
      }
    }
    int h = queue.front().first;
    int w = queue.front().second;
    // printf("h=%d,w=%d, queue size=%d\n",h,w, queue.size());
    queue.pop();
    if (magic[h][w]!=-1 || map[h][w]=='#') continue;
    if (magic[h][w]==-1) {
      magic[h][w] = magicnum;
      // printf("magic[%d][%d]=%d\n", h, w, magic[h][w]);
    }
    // printf("hello\n");
    for (int i=0; i<4; i++) {
      int hh = h+dh[i];
      int ww = w+dw[i];
      if (hh>=0 && hh<H && ww>=0 && ww<W) {
        if (magic[hh][ww]==-1 && map[hh][ww]=='.' && !use[hh][ww]) {
          queue.push(std::make_pair(hh, ww));
          // printf("queue pushing (%d, %d)\n", hh, ww);
          use[hh][ww] = true;
        }
      }
    }
    for (int hh=h-2; hh<=h+2; hh++) {
      for (int ww =w-2; ww<=w+2; ww++) {
        if (hh>=0 && hh<H && ww>=0 && ww<W) {
          if (magic[hh][ww]==-1 && map[hh][ww]=='.' && !use[hh][ww]) {
            queue2.push(std::make_pair(hh, ww));
            // printf("queue2 pushing (%d, %d)\n", hh, ww);
          }
        }
      }
    }
    // printf("queue size=%d, size2=%d\n", queue.size(), queue2.size());
  }
  std::cout << magic[Gh][Gw] << std::endl;
  return 0;
}

Measured memory_bytes: 9080