#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;


bool memo[8][8][8][8][8][8][8][8];

class FC{
public:
	int p[31];
	int n;


	void rot1(){
		swap(p[0],p[1]);
	}
	void rot2(){
		swap(p[0],p[4]);
	}


	void rot3(){
		swap(p[1],p[0]);
	}
	void rot4(){
		swap(p[1],p[2]);
	}
	void rot5(){
		swap(p[1],p[5]);


	}
	void rot6(){
		swap(p[2],p[1]);
	}
	void rot7(){
		swap(p[2],p[3]);
	}
	void rot8(){
		swap(p[2],p[6]);


	}
	void rot9(){
		swap(p[3],p[2]);
	}
	void rot10(){
		swap(p[3],p[7]);


	}
	void rot11(){
		swap(p[4],p[0]);
	}
	void rot12(){
		swap(p[4],p[5]);
	}


	void rot13(){
		swap(p[5],p[4]);
	}
	void rot14(){
		swap(p[5],p[1]);
	}
	void rot15(){
		swap(p[5],p[6]);
	}


	void rot16(){
		swap(p[6],p[5]);
	}
	void rot17(){
		swap(p[6],p[2]);
	}
	void rot18(){
		swap(p[6],p[7]);
	}


	void rot19(){
		swap(p[7],p[6]);
	}
	void rot20(){
		swap(p[7],p[3]);
	}
	void kannmeno(){
		memo[p[0]][p[1]][p[2]][p[3]][p[4]][p[5]][p[6]][p[7]]=true;
	}
	bool kannhanntei(){
		return memo[p[0]][p[1]][p[2]][p[3]][p[4]][p[5]][p[6]][p[7]];
	}
};

int main(){
	while(1){
		for(int a=0;a<8;a++){
			for(int b=0;b<8;b++){
				for(int c=0;c<8;c++){
					for(int d=0;d<8;d++){
						for(int e=0;e<8;e++){
							for(int f=0;f<8;f++){
								for(int g=0;g<8;g++){
									for(int h=0;h<8;h++){
										memo[a][b][c][d][e][f][g][h]=false;
									}
								}
							}
						}
					}
				}
			}	
		}
		int cun=0;
		FC now;
		cin>>cun;
		for(int i=0;i<cun;i++){
			for(int j=0;j<=7;j++){
				cin>>now.p[j];
			}
			now.n=0;
		
			queue<FC>que;
			que.push(now);
			now.kannmeno();
			while(!que.empty()){
				
				now=que.front();
				cout<<now.p[0]<<now.p[1]<<now.p[2]<<now.p[3]<<now.p[4]<<now.p[5]<<now.p[6]<<now.p[7]<<endl;
				que.pop();

				if(now.p[0]==0&&now.p[1]==1&&now.p[2]==2&&now.p[3]==3&&now.p[4]==4&&now.p[5]==5&&now.p[6]==6&&now.p[7]==7){
					cout<<now.n<<endl;
					break;
				}

				 if(now.p[0]==0){
					FC nex1=now;nex1.rot1();
					if(nex1.kannhanntei()==false){
					nex1.n++;que.push(nex1); 
					nex1.kannmeno();
					}
					
					FC nex2=now;nex2.rot2(); 
					if(nex2.kannhanntei()==false){
					nex2.n++;que.push(nex2); 
					nex2.kannmeno();
					}
				}
				else if(now.p[1]==0){
					FC nex3=now;nex3.rot3(); 
					if(nex3.kannhanntei()==false){
					nex3.n++;que.push(nex3); 
					nex3.kannmeno();
					}
					FC nex4=now;nex4.rot4(); 
					if(nex4.kannhanntei()==false){
					nex4.n++;que.push(nex4); 
					nex4.kannmeno();
					}
					FC nex5=now;nex5.rot5(); 
					if(nex5.kannhanntei()==false){
					nex5.n++;que.push(nex5); 
					nex5.kannmeno();
					}
				
				}
				else if(now.p[2]==0){
					
					FC nex6=now;nex6.rot6(); 
					if(nex6.kannhanntei()==false){
					nex6.n++;que.push(nex6); 
					nex6.kannmeno();
					}
					FC nex7=now;nex7.rot7(); 
					if(nex7.kannhanntei()==false){
					nex7.n++;que.push(nex7); 
					nex7.kannmeno();
					}
					FC nex8=now;nex8.rot8(); 
					if(nex8.kannhanntei()==false){
					nex8.n++;que.push(nex8); 
					nex8.kannmeno();
					}
				}
				else if(now.p[3]==0){
					FC nex9=now;nex9.rot9(); 
					if(nex9.kannhanntei()==false){
					nex9.n++;que.push(nex9); 
					nex9.kannmeno();
					}
					FC nex10=now;nex10.rot10(); 
					if(nex10.kannhanntei()==false){
					nex10.n++;que.push(nex10); 
					nex10.kannmeno();
					}
				
					
				}
				else if(now.p[4]==0){
					FC nex11=now;nex11.rot11(); 
					if(nex11.kannhanntei()==false){
					nex11.n++;que.push(nex11); 
					nex11.kannmeno();
					}
					FC nex12=now;nex12.rot12(); 
					if(nex12.kannhanntei()==false){
					nex12.n++;que.push(nex12); 
					nex12.kannmeno();
					}
					
				}
				else if(now.p[5]==0){
					FC nex13=now;nex13.rot13(); 
					if(nex13.kannhanntei()==false){
					nex13.n++;que.push(nex13); 
					nex13.kannmeno();
					}			
					FC nex14=now;nex14.rot14(); 
					if(nex14.kannhanntei()==false){
					nex14.n++;que.push(nex14); 
					nex14.kannmeno();
					}
					FC nex15=now;nex15.rot15(); 
					if(nex15.kannhanntei()==false){
					nex15.n++;que.push(nex15); 
					nex15.kannmeno();
					}
					
				}
				else if(now.p[6]==0){
					FC nex16=now;nex16.rot16(); 
					if(nex16.kannhanntei()==false){
					nex16.n++;que.push(nex16); 
					nex16.kannmeno();
					}
					FC nex17=now;nex17.rot17(); 
					if(nex17.kannhanntei()==false){
					nex17.n++;que.push(nex17); 
					nex17.kannmeno();
					}
					FC nex18=now;nex18.rot18(); 
					if(nex18.kannhanntei()==false){
					nex18.n++;que.push(nex18); 
					nex18.kannmeno();
					}
					
				}
				else if(now.p[7]==0){
					FC nex19=now;nex19.rot19(); 
					if(nex19.kannhanntei()==false){
					nex19.n++;que.push(nex19); 
					nex19.kannmeno();
					}
					FC nex20=now;nex20.rot20(); 
					if(nex20.kannhanntei()==false){
					nex20.n++;que.push(nex20); 
					nex20.kannmeno();
					}
				}
			
			}
		}
	}
	return 0;
}