#include <string>
#include <vector>
#include <cmath>
#include <ctime>
#include <iostream>
#include <cstdio>
#include <set>
#include <map>
#include <queue>
#include <sstream>
#include <algorithm>
#include <numeric>
#include <cstring>
#include <limits>
using namespace std;
typedef long long ll;

enum Face {
	C1, C2, C3, C4, C5, C6, FACE_SIZE
};

struct Dice {
	char face[FACE_SIZE];

	Dice(){}
	Dice(string init){
		for(int i=0;i<FACE_SIZE;i++)face[i] = init[i];
	}

	void roll_y(){
		roll(C2, C3, C5, C4);
	}

	void roll_x(){
		roll(C2, C6, C5, C1);
	}

	void roll_z(){
		roll(C1, C3, C6, C4);
	}

	void roll(Face a, Face b, Face c, Face d){
		char tmp = face[d];
		face[d] = face[c];
		face[c] = face[b];
		face[b] = face[a];
		face[a] = tmp;
	}

	char at(Face a){
		return face[a];
	}
};

bool valid(char a, char b){
	if(tolower(a) != tolower(b))return false;
	if(a == b)return false;
	return true;
}

int dx[] =   {0, 0,  1, -1, 0, 0};
int dy[] =   {1, -1, 0,  0, 0, 0};
int dz[] =   {0, 0,  0,  0, 1, -1};

Face from[] = {C6, C1, C3, C4, C5, C2};
Face to[] =   {C1, C6, C4, C3, C2, C5};

// z y x
bool used[2][2][2];
Dice cube[2][2][2];

bool dfs(int n, int mask, const vector<Dice> &dices){
	if(n >= 8)return true;
	
	int id = n;
	int x = id % 2; id /= 2;
	int y = id % 2; id /= 2;
	int z = id;

	for(int i=0;i<dices.size();i++){
		if((mask >> i) & 1)continue;
		Dice d = dices[i];
		for(int kz=0;kz<4;kz++, d.roll_z()){
			for(int ky=0;ky<4;ky++, d.roll_y()){
				for(int kx=0;kx<4;kx++, d.roll_x()){
					bool ok = true;

					for(int k=0;k<6;k++){
						int nz = z + dz[k];
						int ny = y + dy[k];
						int nx = x + dx[k];

						if(nz < 0 || nz >= 2 || ny < 0 || ny >= 2 || nx < 0 || nx >= 2)continue;
						if(!used[nz][ny][nx])continue;

						if(!valid(d.at(from[k]), cube[nz][ny][nx].at(to[k]))){
							ok = false;
							break;
						}
					}

					if(!ok)continue;

					used[z][y][x] = true;
					cube[z][y][x] = d;

					if(dfs(n + 1, mask | (1 << i), dices))return true;

					used[z][y][x] = false;

					//goto next;
				}
			}
		}

		next:;
	}

	return false;
}
string solve(const vector<Dice> &dices){
	memset(used, false, sizeof(used));
	return dfs(0, 0, dices) ? "YES" : "NO";
}

int main(){
	string init;
	while(cin >> init){
		if(init == "0")break;

		vector<Dice> dices;
		dices.push_back(Dice(init));

		for(int t=0;t<7;t++){
			cin >> init;
			dices.push_back(Dice(init));
		}


		cout << solve(dices) << endl;
	}

	return 0;
}