#include<iostream>
#include<vector>
#include<map>
#include<cstdio>
#include<deque>
#include<cmath>
#include<algorithm>
#define F first
#define S second
#define pb push_back
using namespace std;
typedef pair<int,int> P;
typedef pair<P,P> PP;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<P> VP;
typedef pair<VVI,VP> VVIVP;


map<VVI,int> memo,bidirectional;
VVI final;
VP ini;
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};

P Fpos[] = {P(0,0),P(1,1),P(2,1),P(3,1),P(0,2),P(1,2),P(2,2),P(3,2),P(4,2),P(1,3),P(2,3),P(3,3)};


class Puzzle
{
public:
  VVI state;
  int Manhattan;
  VP vp;

  Puzzle():Manhattan(0){}
  Puzzle(VVI s)
  {
    vp.clear();
    state = s;
    Manhattan_calc(false);
  }

  void Manhattan_calc(bool b)
  {
    Manhattan = 0; 
    for(int i=0;i<5;i++)
      for(int j=0;j<state[i].size();j++)
	if(state[i][j] != 0 && state[i][j] != -1)
	  Manhattan += abs(j-Fpos[state[i][j]].F) + abs(i-Fpos[state[i][j]].S);
	else if(state[i][j] == 0 && !b)// bがfalseなら初期化
	  vp.push_back(P(j,i)); 
  }

  void print()
  {
  
    for(int i=0;i<state.size();i++)
      {
	for(int j=0;j<state[i].size();j++)
	  {
	    if(state[i][j] == -1)
	      cout << "  ";
	    else 
	      cout << state[i][j] << " ";
	  }
	cout << endl;
      }
    cout << endl;
  }
};

bool Input(VVI& puzzle)
{
  puzzle.clear();
  puzzle.resize(5);
  puzzle[0].resize(3),puzzle[1].resize(4),puzzle[2].resize(5),puzzle[3].resize(4),puzzle[4].resize(3);
  puzzle[0][0] = puzzle[0][1] = puzzle[1][0] = puzzle[3][0] = puzzle[4][0] = puzzle[4][1] = -1;
 
  scanf("%d",&puzzle[0][2]);
  if(puzzle[0][2] == -1)
    return false; 
  scanf("%d %d %d",&puzzle[1][1],&puzzle[1][2],&puzzle[1][3]);
  scanf("%d %d %d %d %d",&puzzle[2][0],&puzzle[2][1],&puzzle[2][2],&puzzle[2][3],&puzzle[2][4]);
  scanf("%d %d %d",&puzzle[3][1],&puzzle[3][2],&puzzle[3][3]);
  scanf("%d",&puzzle[4][2]);
	    
    return true;
}

void print(VVI vvi)
{
  cout << "--- print ---" << endl;
  for(int i=0;i<vvi.size();i++)
    {
      for(int j=0;j<vvi[i].size();j++)
	{
	  cout << vvi[i][j] << " ";
	}
      cout << endl;
    }
  cout << endl;
}

VVI change(VVI vec,P p1,P p11)
{
  int tmp = vec[p1.S][p1.F];
  vec[p1.S][p1.F] = vec[p11.S][p11.F];
  vec[p11.S][p11.F] = tmp;

  return vec;
}

void Init()
{
  final.resize(5);
  final[0].pb(-1),final[0].pb(-1),final[0].pb(0);
  final[1].pb(-1),final[1].pb(1),final[1].pb(2),final[1].pb(3);
  final[2].pb(4),final[2].pb(5),final[2].pb(6),final[2].pb(7),final[2].pb(8);
  final[3].pb(-1),final[3].pb(9),final[3].pb(10),final[3].pb(11);
  final[4].pb(-1),final[4].pb(-1),final[4].pb(0);

  Puzzle puz(final); 
  deque<Puzzle> deq;
  deq.push_back(puz);
  bidirectional[final] = 0;
  
  while(!deq.empty())
    {
      Puzzle p = deq.front(); deq.pop_front();
      int cost = bidirectional[p.state];
    
      if(cost >= 4)
	continue;

      for(int i=0;i<2;i++)
	{
	  for(int j=0;j<4;j++)
	    {
	      int nx = p.vp[i].F + dx[j];
	      int ny = p.vp[i].S + dy[j];
	      if(!(0<=ny && ny<p.state.size() && 0<=nx && nx<p.state[ny].size() && p.state[ny][nx] != -1))
		continue;
	      VVI next = change(p.state,p.vp[i],P(nx,ny));
	      map<VVI,int>::iterator it = bidirectional.find(next);
	      if(it == bidirectional.end() || (it != bidirectional.end() && bidirectional[next] > cost + 1))
		{
		  bidirectional[next] = cost + 1;
		  deq.push_back(Puzzle(next));
		}

	    }

	}      

    }
  
  
}


int main()
{
  VVI puzzle;
  Init();
  //cout << "here" << endl;
  while(Input(puzzle))
    {
 
      Puzzle puz(puzzle);
      int men = (1<<28);
      deque<Puzzle> deq;
      deq.push_back(puz);
      memo.clear();
      memo[puzzle] = 0;

      while(!deq.empty())
	{
	  Puzzle p = deq.front(); deq.pop_front();
	  int cost = memo[p.state];
	  //cout << "cost : " << cost << endl;
	  //p.print();
	  if(cost + p.Manhattan > min(20,men))
	    continue;

	  if(p.state == final)
	    {
	      men = min(men,cost);
	      continue;
	    }
	  else if(bidirectional.find(p.state) != bidirectional.end() && cost + bidirectional[p.state] <= 20)
	    {
	      men = min(men,cost+bidirectional[p.state]);
	      continue;
	    }
       
	  for(int i=0;i<2;i++)
	    {
	      for(int j=0;j<4;j++)
		{
  
		  int nx = p.vp[i].F + dx[j];
		  int ny = p.vp[i].S + dy[j];
		  if(!(0<=ny && ny<p.state.size() && 0<=nx && nx<p.state[ny].size() && p.state[ny][nx] != -1))
		    continue;

		  VVI next = change(p.state,p.vp[i],P(nx,ny));
		  map<VVI,int>::iterator it = memo.find(next);
		  if(it == memo.end() || (it != memo.end() &&  memo[next] > cost + 1) )
		    {
		      memo[next] = cost + 1;
		      deq.push_back(Puzzle(next));
		    }

		}
	    }


	}
      if(men == (1<<28))
	cout << "NA" << endl;
      else 
	cout << men << endl;
    }  

    
  return 0;
}


  /*  
  deque<VVIVP> deq;
  VP vec;
  vec.push_back(P(0,0));
  vec.push_back(P(0,4)); 
  deq.push_back(VVIVP(final,vec));
  bidirectional[final] = 0;
  while(!deq.empty())
    {
      VVIVP vvivp = deq.front(); deq.pop_front();
      VVI vvi = vvivp.F;
      VP vp = vvivp.S;
      P p1,p2;
      int cost = bidirectional[vvi];
      if(cost >= 5)
	continue;
      p1 = vp[0];
      p2 = vp[1];
      
      for(int i=0;i<5;i++)
	{
	  int nx1 = p1.F + dx[i];
	  int ny1 = p1.S + dy[i];

	  if(!(0 <= ny1 && ny1 < vvi.size() && 0 <= nx1 && nx1 < vvi[ny1].size()))
	    continue;

	  for(int j=0;j<5;j++)
	    {
	      if(i == 4 && j == 4)
		continue;
	      int nx2 = p2.F + dx[j];
	      int ny2 = p2.S + dy[j];

	      if(!(0 <= ny2 && ny2 < vvi.size() && 0 <= nx2 && nx2 < vvi[ny2].size()))
		continue;
	      VVI new_vvi = change(vvi,p1,P(nx1,ny1),p2,P(nx2,ny2));
	      if(bidirectional.count(new_vvi) == 0 || (bidirectional.count(new_vvi) != 0 && bidirectional[new_vvi] > cost + 1))
		{
		  VP vip;
		  vip.push_back(P(nx1,ny1));
		  vip.push_back(P(nx2,ny2));
		  bidirectional[new_vvi] = cost+1;
		  deq.push_back(VVIVP(new_vvi,vip));
		}

	     

	    }
	}

    }
*/

/*
 int men = (1<<28);
      deque<VVIVP> deq;
      bool fin = false;
      deq.push_back(VVIVP(puzzle,ini));
      memo[puzzle] = 0;
      while(!deq.empty() && !fin)
	{
	  VVIVP vvivp = deq.front(); deq.pop_front();
	  VVI vvi = vvivp.F;
	  VP vp = vvivp.S;
	  P p1,p2;
	  p1 = vp[0], p2 = vp[1];
	 
	  if((vvi == final || bidirectional.count(vvi) != 0) && memo[vvi] + bidirectional[vvi] <= min(20,men))
	    {
	      men = min(men,memo[vvi]+bidirectional[vvi]);
	      continue;
	    }
	  
	  int cost = memo[vvi];

	  if(men <= cost) 
	    continue;

	  for(int i=0;i<5;i++)
	    {
	      int nx1 = p1.F + dx[i];
	      int ny1 = p1.S + dy[i];

	      if(!(0 <= ny1 && ny1 < vvi.size() && 0 <= nx1 && nx1 < vvi[ny1].size()))
		continue;

	      for(int j=0;j<5;j++)
		{
		  if(i = 4 && j == 4)
		    continue;
		  int nx2 = p2.F + dx[j];
		  int ny2 = p2.S + dy[j];
		  
		  if(!(0 <= ny2 && ny2 < vvi.size() && 0 <= nx2 && nx2 < vvi[ny2].size()))
		    continue;

		  //cout << "change! " << i << " - " << j << endl;

		  //cout <<"cost = " << cost << endl;
		   //print(change(vvi,p1,P(nx1,ny1),p2,P(nx2,ny2)));
		  VVI new_vvi = change(vvi,p1,P(nx1,ny1),p2,P(nx2,ny2));
		  if(memo.count(new_vvi) == 0 || (memo.count(new_vvi) != 0 && memo[new_vvi] > cost+1))
		    {
		 
		      memo[new_vvi] = cost+1;
		      VP vip;
		      vip.push_back(P(nx1,ny1));
		      vip.push_back(P(nx2,ny2));
		      deq.push_back(VVIVP(new_vvi,vip));
		    }


		}

	    }

	}

      if(men != (1<<28))
	cout << men << endl;
      else 
	cout << "NA" << endl;
 */


/*
while(Input(puzzle)){
      int men = (1<<28);
      deque<VVIVP> deq;
      bool fin = false;
      deq.push_back(VVIVP(puzzle,ini));
      memo[puzzle] = 0;
      while(!deq.empty())
	{
	  VVIVP vvivp = deq.front(); deq.pop_front();
	  VVI vvi = vvivp.F;
	  VP vp = vvivp.S;
	 
	  if(vvi == final)
	    {
	      men = min(men,memo[vvi]);
	      fin = true;
	    }
	  else if(bidirectional.count(vvi) != 0 && memo[vvi] + bidirectional[vvi] <= 20)
	    {
	      fin = true;
	      men = min(men,memo[vvi]+bidirectional[vvi]);
	      break;
	    }
	 
	  int cost = memo[vvi];
	  if(cost >= men)
	    continue;

	  //cout << "cost = " << cost << endl;
	  P p1,p2;
	  p1 = vp[0];
	  p2 = vp[1];
	  for(int k=0;k<5;k++)
	    {
	      int nx1,ny1;
	      nx1 = vp[0].F + dx[k];
	      ny1 = vp[0].S + dy[k];
	      if(!(0 <= ny1 && vvi.size() > ny1 && 0 <= nx1 && vvi[ny1].size() > nx1))
		continue;

	      for(int l=0;l<5;l++)
		{
		  int nx2,ny2;
	
		  nx2 = vp[1].F + dx[l];
		  ny2 = vp[1].S + dy[l];

		  if(!(0 <= ny2 && vvi.size() > ny2 && 0 <= nx2 && vvi[ny2].size() > nx2))
		    continue;
	
	
		  int tmp = vvi[p1.S][p1.F];
		  vvi[p1.S][p1.F] = vvi[ny1][nx1];
		  vvi[ny1][nx1] = tmp;

		  tmp = vvi[p2.S][p2.F];
		  vvi[p2.S][p2.F] = vvi[ny2][nx2];
		  vvi[ny2][nx2] = tmp;
	

		  if(cost+1 >= 20 && vvi != final)
		    continue;

		  if(cost+1 >= 20 && vvi == final)
		    {
		      fin = true;
		      printf("20\n");
		      break;
		    }

		  if((memo.count(vvi) != 0 && memo[vvi] > cost + 1) || memo.count(vvi) == 0)
		    {
		      VP vip;
		      vip.push_back(P(nx1,ny1));
		      vip.push_back(P(nx2,ny2));
		      memo[vvi] = cost + 1;
		      deq.push_back(VVIVP(vvi,vip)); 
		    }

	
		  tmp = vvi[p1.S][p1.F];
		  vvi[p1.S][p1.F] = vvi[ny1][nx1];
		  vvi[ny1][nx1] = tmp;

		  tmp = vvi[p2.S][p2.F];
		  vvi[p2.S][p2.F] = vvi[ny2][nx2];
		  vvi[ny2][nx2] = tmp;
	
		}
	      if(fin)
		break;
	    }
	  if(fin)
	    break;
	}
      if(!fin)
	printf("NA\n");
      else
	printf("%d\n",men);
    }

 */

Measured memory_bytes: 3088