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 <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define RFOR(i,a,b) for(int i=(b) - 1;i>=(a);i--)
#define REP(i,n) for(int i=0;i<(n);i++)
#define RREP(i,n) for(int i=n-1;i>=0;i--)

#define PB push_back
#define INF INT_MAX/3
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define CLR(a) memset(a,0,sizeof(a))

typedef long long int ll;

using namespace std;
int dx[] = {-1,0,0,1};
int dy[] = {0,1,-1,0};
int xs,ys,tx,ty,kx,ky;


int main(){
    while(true){
	cin >> xs >> ys;
	if(xs == 0 && ys == 0) break;
	cin >> tx >> ty;
	cin >> kx >> ky;
	tx--;
	ty--;
	kx--;
	ky--;
	if(tx==kx&&ty==ky){
	    cout << 0 << endl;
	    continue;
	}
	vector< vector<int> > map(ys,vector<int>(xs));
	REP(i,ys)REP(j,xs) cin >> map[i][j];

	queue<int> qtx;
	queue<int> qty;
	queue<int> qkx;
	queue<int> qky;
	queue<int> qn;
	vector< vector<bool> > tu(ys,vector<bool>(xs,false));
	vector< vector<bool> > ku(ys,vector<bool>(xs,false));
	int ans = 100;
	qtx.push(tx);
	qty.push(ty);
	qkx.push(kx);
	qky.push(ky);
	qn.push(1);
	while(!qtx.empty()){
	    int x1 = qtx.front();
	    int y1 = qty.front();
	    int x2 = qkx.front();
	    int y2 = qky.front();
	    int n = qn.front();
	    if(n >= 100){
		ans = min(ans,100);
		break;
	    }
	    qtx.pop();
	    qty.pop();
	    qkx.pop();
	    qky.pop();
	    qn.pop();
	    REP(i,4){
		int ntx = x1 + dx[i];
		int nty = y1 + dy[i];
		int nkx = x2 - dx[i];
		int nky = y2 - dy[i];
		if(ntx<0 || xs <= ntx) ntx = x1;
		if(nty<0 || ys <= nty) nty = y1;
		if(nkx<0 || xs <= nkx) nkx = x2;
		if(nky<0 || ys <= nky) nky = y2;
		if(map[nty][ntx] == 1) {
		    ntx = x1;
		    nty = y1;
		}
		if(map[nky][nkx] == 1) {
		    nkx = x2;
		    nky = y2;
		}
		if(tu[nty][ntx] && ku[nky][nkx]) continue;
		tu[nty][ntx] = true;
		ku[nky][nkx] = true;
		if(ntx==nkx&&nty==nky){
		    ans = min(ans,n);
		}
		qtx.push(ntx);
		qty.push(nty);
		qkx.push(nkx);
		qky.push(nky);
		qn.push(n+1);
	    }
	}
	if(ans>=100) cout << "NA" << endl;
	else cout << ans << endl;
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
struct po{int x,y,a,b;};
int w,h;
int mp[55][55];
int tx,ty,kx,ky;
int dis[55][55][55][55];

po mkp(int a,int b,int c,int d){
  po res;
  res.x=a, res.y=b, res.a=c,res.b=d;
  return res;
}

int bfs(){
  int dx[]={0,0,-1,1};
  int dy[]={1,-1,0,0};
  memset(dis,0,sizeof(dis));
  queue <po> Q;
  Q.push(mkp(tx,ty,kx,ky));

  while(!Q.empty()){
    po t=Q.front();Q.pop();
    if(dis[t.y][t.x][t.b][t.a]>=100) return -1;
    if(t.x==t.a&&t.y==t.b) return dis[t.y][t.x][t.b][t.a];
    
    for(int i=0;i<4;i++){
      int nx=t.x+dx[i],ny=t.y+dy[i];
      int na=t.a-dx[i],nb=t.b-dy[i];
      if(nx<0||ny<0||nx>=w||ny>=h||mp[ny][nx])nx=t.x,ny=t.y;
      if(na<0||nb<0||na>=w||nb>=h||mp[nb][na])na=t.a,nb=t.b;
      if(dis[ny][nx][nb][na])continue;
      dis[ny][nx][nb][na]=dis[t.y][t.x][t.b][t.a]+1;
      Q.push(mkp(nx,ny,na,nb));
    }
  }
  return -1;
}

int main(){

  while(1){
  cin>>w>>h;
  if(!w&&!h)break;
  cin>>tx>>ty>>kx>>ky;
  tx--,ty--,kx--,ky--;
  for(int i=0;i<h;i++)
    for(int j=0;j<w;j++) cin>>mp[i][j];
  int res=bfs();
  if(res==-1) cout << "NA"<<endl;
  else cout <<res<<endl;

    }
  return 0;
}

C++: #include <iostream>
#include <queue>

using namespace std;

#define fst first
#define scd second
#define mp make_pair
#define rep(i,x) for(int i=0;i<(int)x;++i)
#define rep1(i,x) for(int i=1;i<=(int)x;++i)

class P {
public:
    int x, y;
    P () {
        x = y = 0;
    };
    P (int x0,int y0) {
        x=x0,y=y0;
    };
};

int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};

int d[53][53];
int memo[53][53][53][53];
bool used[53][53][53][53];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int X, Y;
    while (cin >> X >> Y, X || Y) {
        int tx, ty; cin >> tx >> ty;
        int kx, ky; cin >> kx >> ky;
        fill(d[0], d[Y+2], 1);
        rep1(i, Y) rep1(j, X) cin >> d[i][j];

        queue<pair<P, P> > q;

        q.push(mp(P(tx, ty), P(kx, ky)));
        memo[ty][tx][ky][kx] = 0;
        used[ty][tx][ky][kx] = true;

        int ans = -1;

        while (q.size()) {
            pair<P, P> r = q.front(); q.pop();
            P f = r.fst, s = r.scd;

            if (memo[f.y][f.x][s.y][s.x] >= 100) break;

            if (f.x == s.x && f.y == s.y) {
                ans = memo[f.y][f.x][s.y][s.x];
                break;
            }

            rep(i, 4) {
                int nfx = f.x + dx[i], nfy = f.y + dy[i];
                int nsx = s.x - dx[i], nsy = s.y - dy[i];
                if (d[nfy][nfx] == 1) nfx -= dx[i], nfy -= dy[i];
                if (d[nsy][nsx] == 1) nsx += dx[i], nsy += dy[i];
                if (!used[nfy][nfx][nsy][nsx]) {
                    used[nfy][nfx][nsy][nsx] = true;
                    memo[nfy][nfx][nsy][nsx] = memo[f.y][f.x][s.y][s.x] + 1;
                    q.push(mp(P(nfx, nfy), P(nsx, nsy)));
                }
            }
        }

        if (ans == -1) cout << "NA" << endl;
        else cout << ans << endl;
    }
}