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

using namespace std;

int checkTable[40320];

void setNUM(int table[2][4], int x){
    int S = 10000000;
    for(int i=0;i<2;i++){
        for(int k=0;k<4;k++){
            table[i][k] = x/S;
            x = x%S;
            S /= 10;
        }
    }
}

int getNUM(int x){
    switch(x){
    case 0:return 1;
    case 1:return 1;
    case 2:return 2;
    case 3:return 6;
    case 4:return 24;
    case 5:return 120;
    case 6:return 720;
    case 7:return 5040;
    }
    return -1;
}

int makeCode(int Table[2][4]){
    return 10000000*Table[0][0]+1000000*Table[0][1]+100000*Table[0][2]+
            10000*Table[0][3]+1000*Table[1][0]+100*Table[1][1]+ 10*Table[1][2]+
            Table[1][3];
}

int translateORDER(int Table[2][4]){
    long long x = makeCode(Table);
    int checkTable[8] = {0};
    int S = 10000000;
    int ret = 0,small_num_appear_count;
    for(int i=7; i >= 0; i--){
        small_num_appear_count=0;
        for(int k = 0; k < x/S;k++){
            if(checkTable[k] == 1)small_num_appear_count++;
        }
        ret += ((x/S)-small_num_appear_count)*getNUM(i);
        checkTable[(x/S)]=1;
        x %= S;
        S /= 10;
    }

    return ret;
}


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;
}

struct Info{
    Info(){ zero_loc=data = count = 0;}
    Info(int arg_data,int arg_count,short arg_loc){
        data = arg_data;
        count = arg_count;
        zero_loc = arg_loc;
    }
    int data,count;
    short zero_loc;
};

class LongQ{
public:
    LongQ(){
        Q = new Info[40320];
        head = tail = num_of_data=0;
    }

    void enqueue(int arg_data,int arg_count,short arg_loc){
        Q[tail].count = arg_count;
        Q[tail].data = arg_data;
        Q[tail].zero_loc = arg_loc;
        num_of_data++;
        tail = (tail+1)%40320;
    }

    Info dequeue(){
        Info ret = Q[head];
        head = (head+1)%40320;
        num_of_data--;
        return ret;
    }

    bool isEmpty(){
        return num_of_data == 0;
    }

private:
    Info* Q;
    int head,tail,num_of_data;
};

LongQ func(LongQ queue,int table[2][4],Info tmpInfo,short zero_loc){
    if(checkTable[translateORDER(table)] == -1){
        checkTable[translateORDER(table)]=tmpInfo.count;
        queue.enqueue(makeCode(table),tmpInfo.count+1,zero_loc);
    }
    return queue;
}

int main(){

    int table[2][4];

    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){

    	for(int i = 0; i < 40320;i++)checkTable[i]=-1;

    	checkTable[translateORDER(table)]=0;
		LongQ queue;

		queue.enqueue(makeCode(table),0,zeroLoc(table));

		Info tmpInfo;

		while(queue.isEmpty()==false){
			tmpInfo=queue.dequeue();

			int tmpTable[2][4];
			setNUM(tmpTable,tmpInfo.data);
			if(tmpTable[0][0]==0&&tmpTable[0][1]==1&&tmpTable[0][2]==2&&tmpTable[0][3]==3&&
					tmpTable[1][0]==4&&tmpTable[1][1]==5&&tmpTable[1][2]==6&&tmpTable[1][3]==7){
				printf("%d\n",tmpInfo.count);
				break;
			}

			int next_table[4][2][4];

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

			switch(tmpInfo.zero_loc){
			case 0:
				swap(next_table[0][0][0],next_table[0][0][1]);
				queue = func(queue,next_table[0],tmpInfo,1);

				swap(next_table[1][0][0],next_table[1][1][0]);
				queue = func(queue,next_table[1],tmpInfo,10);
				break;
			case 1:
				swap(next_table[0][0][1],next_table[0][0][0]);
				queue = func(queue,next_table[0],tmpInfo,0);

				swap(next_table[1][0][1],next_table[1][0][2]);
				queue = func(queue,next_table[1],tmpInfo,2);

				swap(next_table[2][0][1],next_table[2][1][1]);
				queue = func(queue,next_table[2],tmpInfo,11);
				break;
			case 2:
				swap(next_table[0][0][2],next_table[0][0][1]);
				queue = func(queue,next_table[0],tmpInfo,1);

				swap(next_table[1][0][2],next_table[1][1][2]);
				queue = func(queue,next_table[1],tmpInfo,12);

				swap(next_table[2][0][2],next_table[2][0][3]);
				queue = func(queue,next_table[2],tmpInfo,3);

				break;
			case 3:
				swap(next_table[0][0][3],next_table[0][0][2]);
				queue = func(queue,next_table[0],tmpInfo,2);

				swap(next_table[1][0][3],next_table[1][1][3]);
				queue = func(queue,next_table[1],tmpInfo,13);

				break;
			case 10:
				swap(next_table[0][1][0],next_table[0][0][0]);
				queue = func(queue,next_table[0],tmpInfo,0);

				swap(next_table[1][1][0],next_table[1][1][1]);
				queue = func(queue,next_table[1],tmpInfo,11);

				break;
			case 11:
				swap(next_table[0][1][1],next_table[0][1][0]);
				queue = func(queue,next_table[0],tmpInfo,10);

				swap(next_table[1][1][1],next_table[1][0][1]);
				queue = func(queue,next_table[1],tmpInfo,1);

				swap(next_table[2][1][1],next_table[2][1][2]);
				queue = func(queue,next_table[2],tmpInfo,12);
				break;
			case 12:
				swap(next_table[0][1][2],next_table[0][1][1]);
				queue = func(queue,next_table[0],tmpInfo,11);

				swap(next_table[1][1][2],next_table[1][0][2]);
				queue = func(queue,next_table[1],tmpInfo,2);

				swap(next_table[2][1][2],next_table[2][1][3]);
				queue = func(queue,next_table[2],tmpInfo,13);
				break;
			case 13:
				swap(next_table[0][1][3],next_table[0][0][3]);
				queue = func(queue,next_table[0],tmpInfo,3);

				swap(next_table[1][1][3],next_table[1][1][2]);
				queue = func(queue,next_table[1],tmpInfo,12);

				break;
		}

		}
    }

    return 0;
}