#include <iostream>
#include <fstream>
#include <queue>
#include <algorithm>

using namespace std;

ifstream f ("car.in");
ofstream g ("car.out");

int n,m;
int startx, starty, stopx, stopy;
int mak[501][501];
int cost[501][501][4][4];
int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};

struct Dir
{
    int dirx;
    int diry;
};
struct Nod
{
    int x;
    int y;
    Dir commingdir;
    int val;
};

//queue < Nod> coada;

Nod heap[500004];
int nn;

Nod getMin()
{
    return heap[1];
}

void add(Nod x)
{
    nn++;
    int poz=nn;
    heap[nn]=x;
    while(poz>1 && heap[poz/2].val>heap[poz].val)
    {
        swap(heap[poz/2], heap[poz]);
        poz/=2;
    }
}

int popMin()
{
    heap[1]=heap[nn];
    heap[nn]={0,0,{0,0},0};
    int poz=1;
    nn--;
    while(2*poz<=nn)
    {
        poz*=2;
        if(poz<nn && heap[poz].val>heap[poz+1].val) poz++;
        if(heap[poz].val < heap[poz/2].val)
            swap(heap[poz/2], heap[poz]);
        else poz=nn;
    }
}

bool isok(int x, int y)
{
    if(1<=x && x<=n && 1<=y && y<=m)
        return true;
    return false;
}

void lee()
{
   //coada.push({startx,starty,{0, 0}});
    add({startx,starty,{0, 0}});
    Nod elem={startx, starty};
    int inext, jnext;
    while(nn>0)
    {
        elem=getMin();

        int icurent = elem.x;
        int jcurent = elem.y;
        Dir dirr=elem.commingdir;
        popMin();
        Nod child;
        Dir d;
        if(dirr.dirx==0 && dirr.diry==0)
        {
            for(int dd=0;dd<8;++dd)
            {
                inext=icurent+dx[dd];
                jnext=jcurent+dy[dd];
                if(isok(inext, jnext))
                {
                    if(icurent==startx && jcurent==starty && mak[inext][jnext]==0)
                    {
                       // mak[inext][jnext]=mak[icurent][jcurent];
                        child.x=inext;
                        child.y=jnext;
                        d.dirx=inext-startx;
                        d.diry=-(jnext-starty);
                        child.commingdir=d;
                        cost[inext][jnext][d.dirx+1][d.diry+1]=0;
                        child.val=0;
                        add(child);
                    }
                }
            }
        }
        else
        {
            for(int dd=0;dd<8;++dd)
            {
                inext=icurent+dx[dd];
                jnext=jcurent+dy[dd];
                if(isok(inext, jnext) && mak[inext][jnext]==0)
                {
                    //cout<<"k";
                    child.x=inext;
                    child.y=jnext;
                    d.dirx=inext-icurent;
                    d.diry=-(jnext-jcurent);
                    Dir cdir;
                    cdir.dirx=2*(d.dirx*dirr.dirx+d.diry*dirr.diry)/(dirr.dirx*dirr.dirx+dirr.diry*dirr.diry);
                    cdir.diry=2*(d.diry*dirr.dirx - d.dirx*dirr.diry)/(dirr.dirx*dirr.dirx+dirr.diry*dirr.diry);
                    if(abs(cdir.dirx)==2 )
                    {
                        cdir.dirx/=2;
                        cdir.diry/=2;
                    }
                    else
                        if(abs(cdir.diry)==2 )
                        {
                            cdir.dirx/=2;
                            cdir.diry/=2;
                        }
                    child.commingdir=d;
                    if(cdir.dirx==1&& cdir.diry==0 && (cost[inext][jnext][d.dirx+1][d.diry+1]>cost[icurent][jcurent][elem.commingdir.dirx+1][elem.commingdir.diry+1]) )
                            cost[inext][jnext][d.dirx+1][d.diry+1]=cost[icurent][jcurent][elem.commingdir.dirx+1][elem.commingdir.diry+1] , child.val=0, add(child) ;
                    else
                        if(cdir.dirx==1&& abs(cdir.diry)==1 && (cost[inext][jnext][d.dirx+1][d.diry+1]>cost[icurent][jcurent][elem.commingdir.dirx+1][elem.commingdir.diry+1]+1 ))
                            cost[inext][jnext][d.dirx+1][d.diry+1]=cost[icurent][jcurent][elem.commingdir.dirx+1][elem.commingdir.diry+1]+1 , child.val=1, add(child);
                        else
                            if(cdir.dirx==0&& abs(cdir.diry)==1 && (cost[inext][jnext][d.dirx+1][d.diry+1]>cost[icurent][jcurent][elem.commingdir.dirx+1][elem.commingdir.diry+1]+2))
                                cost[inext][jnext][d.dirx+1][d.diry+1]=cost[icurent][jcurent][elem.commingdir.dirx+1][elem.commingdir.diry+1]+2 , child.val=2, add(child);
                }
            }
        }
    }
}

int main()
{
    f>>n>>m>>startx>>starty>>stopx>>stopy;
    //  if(mak[startx][starty]==-1)
    for(int i=1;i<=n;++i)
    {
        for(int j=1;j<=m;++j)
        {
            cost[i][j][0][0]=1e9;
            cost[i][j][0][1]=1e9;
            cost[i][j][0][2]=1e9;
            cost[i][j][1][0]=1e9;
            cost[i][j][1][1]=1e9;
            cost[i][j][1][2]=1e9;
            cost[i][j][2][0]=1e9;
            cost[i][j][2][1]=1e9;
            cost[i][j][2][2]=1e9;
            f>>mak[i][j];

        }
    }
    if(mak[startx][starty]==1 || mak[stopx][stopy] == 1)
    {
        g<<"-1";
        return 0;
    }
    cost[startx][starty][0][0]=0;
    cost[startx][starty][0][1]=0;
    cost[startx][starty][0][2]=0;
    cost[startx][starty][1][0]=0;
    cost[startx][starty][1][1]=0;
    cost[startx][starty][1][2]=0;
    cost[startx][starty][2][0]=0;
    cost[startx][starty][2][1]=0;
    cost[startx][starty][2][2]=0;
    lee();
    int mi=1e9;
    for(int di=0;di<3;++di)
    {
        for(int dj=0;dj<3;++dj)
        {
            //g<<cost[stopx][stopy][di][dj]<<" ";
            //  if(cost[stopx][stopy][di][dj]!=0)
            mi=min(cost[stopx][stopy][di][dj],mi);
        }
        //  g<<"\n";
    }
    if(mi==1e9)
        mi=-1;
    g<<mi;
    return 0;
}