#include <stdio.h>
#include <math.h>
#include <algorithm>

using namespace std;

int minimum = -1;


int calcDiffSum(int table[2][4]){
    int sum = 0;
    for(int row=0;row<2;row++){
        for(int col=0;col<4;col++){
            if(table[row][col] != 0){
                sum += abs((table[row][col])/4-row) + abs((table[row][col])%4-col);
            }
        }
    }
    return sum;
}

int zeroLoc(int table[2][4]){
    int zero_loc;
    for(int i=0;i<2;i++){
        for(int k=0;k<4;k++){
            if(table[i][k]==0){
                zero_loc=10*i+k;
            }
        }
    }
    return zero_loc;
}

void recursive(int table[2][4],int max_depth,int count,int pre_loc,int zero_loc){
	int diffSum = calcDiffSum(table);
	if(count == max_depth && diffSum == 0){
		minimum = max_depth;
		return;
	}

	if(minimum != -1)return;

	int next_table[3][2][4];
	int dif1,dif2,dif3,dif4;


	switch(zero_loc){
	case 0:
		for(int a=0;a<2;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 1){
			if((table[0][1])%4==0){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][0][0],next_table[0][0][1]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,1);
			}
		}
		if(pre_loc != 10){
			if((table[1][0])/4==0){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][0][0],next_table[1][1][0]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,10);
			}
		}
		break;
	case 1:

		for(int a=0;a<3;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 0){
			if((table[0][0])%4>=1){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][0][1],next_table[0][0][0]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,0);
			}
		}
		if(pre_loc != 11){
			if((table[1][1])/4==0){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][0][1],next_table[1][1][1]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,11);
			}
		}
		if(pre_loc != 2){
			if((table[0][2])%4<=1){
				dif3 = diffSum - 1;
			}else{
				dif3 = diffSum + 1;
			}
			swap(next_table[2][0][1],next_table[2][0][2]);
			if(count < max_depth && dif3 <= max_depth-count){
				recursive(next_table[2],max_depth,count+1,zero_loc,2);
			}
		}
		break;
	case 2:
		for(int a=0;a<3;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 1){
			if((table[0][1])%4>=2){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][0][2],next_table[0][0][1]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,1);
			}
		}
		if(pre_loc != 12){
			if((table[1][2])/4==0){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][0][2],next_table[1][1][2]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,12);
			}
		}
		if(pre_loc != 3){
			if((table[0][3])%4<=2){
				dif3 = diffSum - 1;
			}else{
				dif3 = diffSum + 1;
			}
			swap(next_table[2][0][2],next_table[2][0][3]);
			if(count < max_depth && dif3 <= max_depth-count){
				recursive(next_table[2],max_depth,count+1,zero_loc,3);
			}
		}
		break;
	case 3:
		for(int a=0;a<2;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 2){
			if((table[0][2])%4==3){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][0][3],next_table[0][0][2]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,2);
			}
		}
		if(pre_loc != 13){
			if((table[1][3])/4==0){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][0][3],next_table[1][1][3]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,13);
			}
		}
		break;
	case 10:
		for(int a=0;a<2;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 0){
			if((table[0][0])/4==1){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][1][0],next_table[0][0][0]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,0);
			}
		}
		if(pre_loc != 11){
			if((table[1][1])%4==0){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][1][0],next_table[1][1][1]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,11);
			}
		}
		break;
	case 11:
		for(int a=0;a<3;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 1){
			if((table[0][1])/4==1){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][1][1],next_table[0][0][1]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,1);
			}
		}
		if(pre_loc != 10){
			if((table[1][0])%4>=1){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][1][1],next_table[1][1][0]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,10);
			}
		}
		if(pre_loc != 12){
			if((table[1][2])%4<=1){
				dif3 = diffSum - 1;
			}else{
				dif3 = diffSum + 1;
			}
			swap(next_table[2][1][1],next_table[2][1][2]);
			if(count < max_depth && dif3 <= max_depth-count){
				recursive(next_table[2],max_depth,count+1,zero_loc,12);
			}
		}
		break;
	case 12:
		for(int a=0;a<3;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 2){
			if((table[0][2])/4==1){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][1][2],next_table[0][0][2]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,2);
			}
		}
		if(pre_loc != 11){
			if((table[1][1])%4>=2){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][1][2],next_table[1][1][1]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,11);
			}
		}
		if(pre_loc != 13){
			if((table[1][3])%4<=2){
				dif3 = diffSum - 1;
			}else{
				dif3 = diffSum + 1;
			}
			swap(next_table[2][1][2],next_table[2][1][3]);
			if(count < max_depth && dif3 <= max_depth-count){
				recursive(next_table[2],max_depth,count+1,zero_loc,13);
			}
		}
		break;
	case 13:

		for(int a=0;a<2;a++){
			for(int b=0;b<2;b++){
				for(int c=0;c<4;c++){
					next_table[a][b][c] = table[b][c];
				}
			}
		}

		if(pre_loc != 3){
			if((table[0][3])/4==1){
				dif1 = diffSum - 1;
			}else{
				dif1 = diffSum + 1;
			}
			swap(next_table[0][1][3],next_table[0][0][3]);
			if(count < max_depth && dif1 <= max_depth-count){
				recursive(next_table[0],max_depth,count+1,zero_loc,3);
			}
		}
		if(pre_loc != 12){
			if((table[1][2])%4==3){
				dif2 = diffSum - 1;
			}else{
				dif2 = diffSum + 1;
			}
			swap(next_table[1][1][3],next_table[1][1][2]);
			if(count < max_depth && dif2 <= max_depth-count){
				recursive(next_table[1],max_depth,count+1,zero_loc,12);
			}
		}
		break;


	}
}


void func(int table[2][4],int max_depth){
	while(minimum == -1){
		recursive(table,max_depth,0,-1,zeroLoc(table));
		max_depth += 2;
	}
}


int main(){

    int table[2][4],start_count;

    while(scanf("%d %d %d %d %d %d %d %d",&table[0][0],&table[0][1],&table[0][2],&table[0][3],&table[1][0],&table[1][1],&table[1][2],&table[1][3])!=EOF){
    	start_count = calcDiffSum(table);

		func(table,start_count);

		printf("%d\n",minimum);

    	minimum = -1;
    }



    return 0;
}