#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;
#define BIG_NUM 2000000000
#define MOD NUM000007
#define EPS 0.0000001
#define NUM 1440
using namespace std;

enum HOUSE{
	L,
	R,
};

enum Type{
	Normal,
	Ladder,
	Slide,
};

struct Info{
	HOUSE house;
	int loc,count;
};

Type types[3] = {Normal,Ladder,Slide};

int main(){

	Type L_House[101],R_House[101];

	Info first_L,first_R;
	queue<Info>Q;

	int N,ans,tmp,next_loc;
	bool FLG,check[2][100];

	while(true){
		scanf("%d",&N);
		if(N == 0)break;

		ans = BIG_NUM;

		for(int i = 0; i < N; i++){
			scanf("%d",&tmp);
			L_House[i] = types[tmp];
		}

		for(int i = 0; i < N; i++){
			scanf("%d",&tmp);
			R_House[i] = types[tmp];
		}

		L_House[N] = Normal;
		R_House[N] = Normal;

		for(int i = 0; i < 2; i++){
			for(int k = 0; k < N; k++){
				check[i][k] = false;
			}
		}

		first_L.house = L;
		first_R.house = R;

		first_L.loc = 0;
		first_R.loc = 0;

		first_L.count = 0;
		first_R.count = 0;

		check[L][0] = true;
		check[R][0] = true;

		if(L_House[0] == Ladder){

			for(int i = 1; i <= N-1; i++){
				if(L_House[i] == Ladder){
					first_L.loc++;
					check[L][i] = true;
				}else{
					break;
				}
			}
		}

		if(R_House[0] == Ladder){

			for(int i = 1; i <= N-1; i++){
				if(R_House[i] == Ladder){
					first_R.loc++;
					check[R][i] = true;
				}else{
					break;
				}
			}
		}

		while(!Q.empty())Q.pop();

		Q.push(first_L);
		Q.push(first_R);

		while(!Q.empty()){

			if(Q.front().loc >= N-1){
				ans = Q.front().count;
				break;
			}

			if(Q.front().house == L){

				for(int i = 0; i <= 2; i++){
					next_loc = Q.front().loc+i;

					if(check[R][next_loc] == false){
						Info info;

						info.count = Q.front().count+1;
						check[R][next_loc] = true;
						info.house = R;

						switch(R_House[next_loc]){
						case Normal:
							info.loc = next_loc;
							Q.push(info);
							break;
						case Ladder:
							FLG = true;
							for(++next_loc;;next_loc++){

								if(R_House[next_loc] != Ladder){
									next_loc--;
									break;
								}else{ //R_House[nextl_loc] == Ladder

									if(check[R][next_loc] == true){
										FLG = false;
										break;
									}
									check[R][next_loc] = true;
								}
							}

							if(FLG){
								info.loc = next_loc;
								Q.push(info);
							}
							break;
						case Slide:
							FLG = true;
							for(--next_loc;;next_loc--){
								if(check[R][next_loc] == true){
									FLG = false;
									break;
								}

								check[R][next_loc] = true;

								if(R_House[next_loc] != Slide){
									break;
								}
							}

							if(FLG){
								info.loc = next_loc;
								Q.push(info);
							}
							break;
						}
					}
				}

			}else{

				for(int i = 0; i <= 2; i++){
					next_loc = Q.front().loc+i;

					if(check[L][next_loc] == false){
						Info info;

						info.count = Q.front().count+1;
						check[L][next_loc] = true;
						info.house = L;

						switch(L_House[next_loc]){
						case Normal:
							info.loc = next_loc;
							Q.push(info);
							break;
						case Ladder:
							FLG = true;
							for(++next_loc;;next_loc++){

								if(L_House[next_loc] != Ladder){
									next_loc--;
									break;
								}else{ //L_House[nextl_loc] == Ladder

									if(check[L][next_loc] == true){
										FLG = false;
										break;
									}
									check[L][next_loc] = true;
								}
							}

							if(FLG){
								info.loc = next_loc;
								Q.push(info);
							}
							break;
						case Slide:
							FLG = true;
							for(--next_loc;;next_loc--){
								if(check[L][next_loc] == true){
									FLG = false;
									break;
								}

								check[L][next_loc] = true;

								if(L_House[next_loc] != Slide){
									break;
								}
							}

							if(FLG){
								info.loc = next_loc;
								Q.push(info);
							}
							break;
						}
					}
				}
			}
			Q.pop();
		}

		if(ans == BIG_NUM)printf("NA\n");
		else{
			printf("%d\n",ans);
		}
	}

	return 0;
}