#include<complex>
#include<algorithm>
#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>
#include<map>
#include<sstream>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<cassert>
#include<deque>
#include<queue>
#include<climits>
#include<list>
#include<stack>
#include<ctime>
#define all(n) n.begin(),n.end()
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define PPPinsert(a,b,c,d,e,f) PPP(PP(P(a,b),P(c,d)),P(e,f))
#define F first
#define S second
#define pb push_back
#define INF (1<<27)
#define EPS 1e-10
#define equals(a,b) (fabs((a)-(b)) < EPS)

using namespace std;
typedef pair<int,int> P;
typedef pair<P,P> PP;
typedef pair<PP,P> PPP;
typedef unsigned long long ull;
typedef long long ll;
const int dx[4] = {0,1,0,-1};
const int dy[4] = {1,0,-1,0};

int rdir(int i){
  switch(i){
  case 0:
    return 2;
  case 1:
    return 3;
  case 2:
    return 0;
  case 3: 
    return 1;
  default:
    return -1; 
  }
}

class Pox{
private:
  PPP element;
public:

  Pox(){}
  Pox(PPP element):element(element){}

  PPP get(){
    return element;
  }  

};

struct Comparator_X{
  bool operator() (Pox &a,Pox &b){
    if(a.get().S.F != a.get().S.F)return a.get().S.F < b.get().S.F;
    return a.get().S.S < b.get().S.S;
  }
};

int main(){
  int h,w;
  while(true)
    {
    
      cin >> w >> h;
      if(w+h == 0)break;
      P takayuki,kazuyuki;
      cin >> takayuki.F >> takayuki.S;
      cin >> kazuyuki.F >> kazuyuki.S;
      takayuki.F--,takayuki.S--,kazuyuki.F--,kazuyuki.S--;
      PPP first_element;//PPP(PP(P(takayuki-x,takayuki-y),P(kazuyuki-x,kazuyuki-y)),P(cost,distance))
      first_element = PPPinsert(takayuki.F,takayuki.S,kazuyuki.F,kazuyuki.S,0,abs(takayuki.F-kazuyuki.F)+abs(takayuki.S-kazuyuki.S));


      bool bmap[h][w];
      bool used_X[h][w][h][w];
      rep(i,h)
	{
	  rep(j,w)
	    {
	      cin >> bmap[i][j];
	      rep(k,h)
		rep(l,w)
		  used_X[i][j][k][l] = false;
	    }
	}

      if(takayuki.F == kazuyuki.F && takayuki.S == kazuyuki.S){
	cout << 0 << endl;
	continue;
      }

      used_X[takayuki.S][takayuki.F][kazuyuki.S][kazuyuki.F] = true;

      //priority_queue<Pox,vector<Pox>,Comparator_X> pq;
      Pox fst = Pox(first_element);
      //pq.push(fst);
      deque<Pox> deq;
      deq.push_front(fst);

      bool fin = false;

      int men = INF; 

      while(!deq.empty())
	{
	  //Pox pox = pq.top(); pq.pop();	  
	  //pox.print();
	  Pox pox = deq.front(); deq.pop_front();
	  if(pox.get().S.F >= men)continue;

	  for(int i=0;i<4;i++)
	    {
	      int t_nx,t_ny,h_nx,h_ny;
	      t_nx = pox.get().F.F.F + dx[i],t_ny = pox.get().F.F.S + dy[i];
	      h_nx = pox.get().F.S.F + dx[rdir(i)],h_ny = pox.get().F.S.S + dy[rdir(i)];

	      
	      if( (bmap[t_ny][t_nx] || !(0<= t_nx && t_nx <w && 0 <= t_ny && t_ny < h)) && (bmap[h_ny][h_nx] || !(0<= h_nx && h_nx <w && 0<= h_ny && h_ny <h)) )
	      continue;
	      
	      if(!(0<= t_nx && t_nx < w && 0<= t_ny && t_ny < h) || bmap[t_ny][t_nx])
		t_nx = pox.get().F.F.F,t_ny = pox.get().F.F.S;

	      if(!(0<= h_nx && h_nx < w && 0<= h_ny && h_ny < h) || bmap[h_ny][h_nx])
		h_nx = pox.get().F.S.F,h_ny = pox.get().F.S.S;

	  
	      if(used_X[t_ny][t_nx][h_ny][h_nx])	
		continue;	      

	      if(t_nx == h_nx && t_ny == h_ny)
		{
		  men = min(men,pox.get().S.F+1);
		  fin = true;
		  break;
		}

	  
	      used_X[t_ny][t_nx][h_ny][h_nx] = true;
	      Pox inpox = Pox(PPPinsert(t_nx,t_ny,h_nx,h_ny,pox.get().S.F+1,abs(t_nx-h_nx)+abs(t_ny-h_ny)));
	      //pq.push(inpox);
	      if(deq.front().get().S.F >= inpox.get().S.F)
		{
		  deq.push_front(inpox);
		}	    
	      else 
		{
		  deq.push_back(inpox);
		}


	    }
	  //if(fin)break;
	}      

      if(!fin)
	cout << "NA" << endl;
      else
	cout << men << endl;

      
    }
  return 0;
}

Measured memory_bytes: 7604