/*
    题意：给出一个4*6的网格，有3种颜色，每种8个，先给出网格求最少步数使得中间8个同一颜色
    操作是对每一行、列shift
    
    解题报告：
    "BFS will be worked at this problem.
    Since the final state is determinate, we can do BFS at first to find out the answer for all states.
    The state is only decide by the locations of the 8 squares you choose. It is Combination(24,8)"

    由于最终状态确定的，所以可以从目标状态搜出去，预处理所有情况
    更精彩的是，状态总共只有C(24,8)种！
    把最终处在中间的那8个格子的颜色看为1，其余的看为0，这样那8个格子在24个网格的分布就是状态了
    反过来，确定要把某8个格子移到中间，其余颜色的都是不管的，所以就8个1,16个0

    我的写法超时，写的好搓，对于shift,我是一个一个swap

    请教了Resty的写法，很不错，很快，以下代码是参考他的
    
    左移，就是next[i] = now[i+1]
    右移，就是next[i] = now[i-1]

    可以预先把位置存下来，如第二行就6 7 8 9 10 11
    然后next[pos[i]] = now[pos[i+1]]就行了
    对于右移，再存多一个反过来的，即11 10 9 8 7 6
    这样next[pos[i]] = now[pos[i+1]]也是正确的

*/
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int MAXN = 735471; //C(24,8)
const int INF = 1000000000;

#define move(i) (1<<(i))
#define get(x,i) (x&(1<<(i)))

char step[1<<24];//0 for haven't sovle
int Q[MAXN+10];
int num[20] , pos[20][7];//20种操作


int change(int now , int id)
{
    int next = now;
    int *p = pos[id] , n = num[id];
    for(int i = 0; i < n ; i++)//next[p[i]] = now[p[i+1]]
    {
        int nowPos = p[(i+1)%n] , nextPos = p[i];
        if(get(now,nowPos))next |= move(nextPos);
        else next ^= get(next,nextPos);//set 0
    }
    return next;
}

void init()
{
    //row pos
    // 0 1 2 3 4 5
    // 5 4 3 2 1 0
    for(int id = 0 ; id < 8 ; id++)
    {
        num[id] = 6;
        for(int j = 0; j < 6 ; j++)
        {
            pos[id][j] = id/2*6 + j;
        }
        if(id&1)reverse(pos[id],pos[id]+6);
    }
    //col pos
    // 0 18
    // 6 12  
    // 12 6
    // 18 0 
    for(int id = 8 ; id < 20 ; id++)
    {
        num[id] = 4;
        for(int j = 0 ; j < 4 ; j++)
        {
            pos[id][j] = 6*j + (id-8)/2;
        }
        if(id&1)reverse(pos[id],pos[id]+4);
    }

    int start = (15<<13) + (15<<7);
    step[start] = 1;//
    int front = 0 , tail = 0;
    Q[tail++] = start;
    while(front < tail)
    {
        int state = Q[front++];
        for(int id = 0 ; id < 20 ; id++)
        {
            int nextState = change(state,id);
            if(step[nextState] == 0)
            {
                step[nextState] = step[state]+1;
                Q[tail++] = nextState;
            }
        }
    }
}

int main()
{

#ifdef ONLINE_JUDGE
#else 
    freopen("in","r",stdin);
#endif

    init();

    char str[4][7] , ch[3] = {'G','W','B'};

    int T , t = 1;
    for( scanf("%d",&T) ; T -- ; )
    {
        for(int i = 0 ; i < 4; i++)
        {
            scanf("%s",str[i]);
        }
        int ans = INF;
        for(int k = 0 ; k < 3 ; k++)
        {
            int state = 0;
            for(int i = 0 ; i < 4 ; i++)
                for(int j = 0 ; j < 6 ; j++)
                    if(str[i][j] == ch[k] )state |= move(6*i+j);
            ans = min(ans , (int)step[state]);
        }
        printf("Case %d: %d\n",t++,ans-1);
    }
    return 0;
}