Go: package main

import (
	"fmt"
	"math"
)

type Position struct {
	X int64
	Y int64
}

func (one Position) Distance(another Position) int64 {
	return int64(math.Abs(float64(one.X-another.X)) + math.Abs(float64(one.Y-another.Y)))
}

type PersonPosition struct {
	Takayuki Position
	Kazuyuki Position
}

func (one PersonPosition) Distance() int64 {
	return one.Takayuki.Distance(one.Kazuyuki)
}

type Status struct {
	Person PersonPosition
	Turn   int64
}

type PQStatus []*Status

func solve(h, w int64) {
	var tx, ty, kx, ky int64
	fmt.Scan(&tx, &ty, &kx, &ky)
	tx--
	ty--
	kx--
	ky--
	m := make([][]int64, h)
	for i := range m {
		m[i] = make([]int64, w)
		for j := int64(0); j < w; j++ {
			fmt.Scan(&m[i][j])
		}
	}
	start := &Status{Person: PersonPosition{Takayuki: Position{X: tx, Y: ty}, Kazuyuki: Position{X: kx, Y: ky}}, Turn: 0}
	pq := make(PQStatus, 0)
	pq = append(pq, start)
	dx := []int64{0, 1, 0, -1}
	dy := []int64{1, 0, -1, 0}
	memo := make(map[PersonPosition]int64, 0)
	ans := int64(102)
	for len(pq) > 0 {
		now := &Status{}
		now = pq[0]
		pq = pq[1:]
		if ans <= now.Turn {
			continue
		}
		if _, ok := memo[now.Person]; ok {
			continue
		}
		memo[now.Person] = now.Turn

		if now.Person.Distance() == 0 && ans > now.Turn {
			ans = now.Turn
		}

		for i := 0; i < 4; i++ {
			next := &Status{}
			next = now
			next.Person.Kazuyuki.X += dx[i]
			next.Person.Kazuyuki.Y += dy[i]
			if next.Person.Kazuyuki.X < 0 || next.Person.Kazuyuki.X >= w ||
				next.Person.Kazuyuki.Y < 0 || next.Person.Kazuyuki.Y >= h ||
				m[next.Person.Kazuyuki.Y][next.Person.Kazuyuki.X] == 1 {
				next.Person.Kazuyuki.X -= dx[i]
				next.Person.Kazuyuki.Y -= dy[i]
			}
			next.Person.Takayuki.X -= dx[i]
			next.Person.Takayuki.Y -= dy[i]
			if next.Person.Takayuki.X < 0 || next.Person.Takayuki.X >= w ||
				next.Person.Takayuki.Y < 0 || next.Person.Takayuki.Y >= h ||
				m[next.Person.Takayuki.Y][next.Person.Takayuki.X] == 1 {
				next.Person.Takayuki.X += dx[i]
				next.Person.Takayuki.Y += dy[i]
			}
			next.Turn++
			if next.Turn <= 100 {
				pq = append(pq, next)
			}
		}
	}
	if ans == 102 {
		fmt.Println("NA")
	} else {
		fmt.Println(ans)
	}
}

func main() {
	var h, w int64
	for {
		fmt.Scan(&h, &w)
		if h == 0 && w == 0 {
			break
		}
		solve(h, w)
	}
}

C++: #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);
		  cout << pox.get().S.F+1 << endl;
		  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;
     
      
    }
  return 0;
}

C++: #include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
const int INF=1e9;
const int MOD=100000;
int B=1000000;
int dtx[4]={0,1,0,-1};
int dty[4]={1,0,-1,0};
int dkx[4]={0,-1,0,1};
int dky[4]={-1,0,1,0};
bool fld[50][50];
bool used[50][50][50][50];
struct A{int tx,ty,kx,ky,cnt;};
int X,Y;
bool pos(int x,int y){
      if(x<0||x>=X||y<0||y>=Y)return false;
      if(fld[x][y])return false;
      return true;
}
int main(){
      int tx,ty,kx,ky;
      while(cin>>X>>Y&&(X||Y)){
            int ans=-1;
            memset(used,false,sizeof(used));
            cin>>tx>>ty>>kx>>ky;tx--;ty--;kx--;ky--;
            REP(i,Y)REP(j,X)cin>>fld[j][i];
            queue<A>Q;
            Q.push((A){tx,ty,kx,ky,0});
            while(Q.size()){
                  A a=Q.front();Q.pop();
                  if(a.cnt>=100)continue;
                  if(a.tx==a.kx&&a.ty==a.ky){
                        ans=a.cnt;
                        break;
                  }
                  //cout<<a.tx<<" "<<a.ty<<" "<<a.cnt<<" "<<a.kx<<" "<<a.ky<<endl;
                  REP(i,4){
                        int ntx=a.tx+dtx[i],nty=a.ty+dty[i];
                        int nkx=a.kx+dkx[i],nky=a.ky+dky[i];
                        if(!pos(ntx,nty)||!pos(nkx,nky)||used[ntx][nty][nkx][nky])continue;
                        used[ntx][nty][nkx][nky]=true;
                        Q.push((A){ntx,nty,nkx,nky,a.cnt+1});
                  }
            }
            if(ans==-1)cout<<"NA"<<endl;
            else cout<<ans<<endl;
      }
}