Problem

Susie and Calvin are classmates. Calvin would like to be able to pass notes to Susie in class without their teacher or other classmates knowing what they are talking about, just in case the notes fall into the wrong hands. Calvin has devised the a system to encrypt his messages.

Calvin only passes one word to Susie each time, and that word consists of only uppercase letters, because Calvin is so excited to talk to Susie. Each word is encrypted as follows:

Calvin assigns a number to each letter based on the letter's position in the alphabet, where A = 0, B = 1, ..., Z = 25.
For every letter in the word, Calvin determines the encrypted value of the letter by summing the values of the 1 or 2 letter(s) that are adjacent to that letter in the word. He takes that sum modulo 26, and this is the new value of the letter. Calvin then converts the value back to an uppercase letter based on positions in the alphabet, as before.
The encrypted word is determined by encrypting every letter in the word using this method. Each letter's encryption is based only on the letters from the original unencrypted message, and not on any letters that have already been encrypted
Let's take a look at one of the notes Calvin is writing for Susie. Since Calvin is always hungry, he wants to let Susie know that he wants to eat again. Calvin encrypts the word SOUP as follows:

S = 18, O = 14, U = 20, and P = 15.
Calvin encrypts each letter based on the values of its neighbor(s):
First letter: 14 mod 26 = 14.
Second letter: (18 + 20) mod 26 = 12.
Third letter: (14 + 15) mod 26 = 3.
Fourth letter: 20 mod 26 = 20.
The values 14 12 3 20 correspond to the letters OMDU, and this is the encrypted word that Calvin will write on the note for Susie.
It is guaranteed that Calvin will not send Susie any words that cannot be decrypted at all. For example, Calvin would not send Susie the word APE, since it does not have any valid decryptions. (That is, there is no word that Calvin could have encrypted to APE.)

However, Calvin's system is not perfect, and some of the words he sends Susie can actually be decrypted to multiple words, creating ambiguity! For example, BCB can be decrypted to ABC or CBA, among other possibilities.

Susie pulled another all-nighter yesterday to finish school projects, and she is too tired to decrypt Calvin's messages. She needs your help!

Input

The first line of the input gives the number of test cases, T. T test cases follow. Each case is a single line that contains a string W of uppercase letters: an encrypted word that Calvin has sent.

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the decrypted word, or AMBIGUOUS if it is impossible to uniquely determine the decrypted word.

Limits

1 ≤ T ≤ 100.
W consists of only of uppercase English letters.
W is decryptable to one or more words. (That is, W is the result of an encryption of some word.)
W does not decrypt to the word AMBIGUOUS. (You will only output that when the decryption is ambiguous.)
Small dataset

2 ≤ the length of W ≤ 4.
Large dataset

2 ≤ the length of W ≤ 50.
Sample

Input
3
OMDU
BCB
AOAAAN

Output
Case #1: SOUP
Case #2: AMBIGUOUS
Case #3: BANANA
Note that the last sample case would not appear in the Small dataset.
Sample Cases #1 & #2 were explained in the problem statement.
In Sample Case #3, BANANA is the only word that encrypts to AOAAAN.

分析

通过相邻的字母相加并取余26，得到新的字母。先得出前后两个字母，然后根据其和是否大于其中一个数，来得出另一个数。最后要判断是否能得到结果，如果不能，说明是对称的，出现多个反加密字母，需要舍去。
大小测试数据集都通过：

#include "stdio.h"
int main()
{
    int n,i=0,j=0;
    FILE *fp1, *fp2;
    fp1 = fopen("A-large-practice.in","r");
    fp2 = fopen("A-large-practice.out","w");
    fscanf(fp1,"%d",&n);
    for(i=1;i<=n;i++)
    {
        char a[100];
        char b[100]={0};
        fscanf(fp1,"%s",a);
        int alength=0;
        while(a[alength]!='\0')
            alength++;
        b[1]=a[0];
        b[alength-2]=a[alength-1];
        b[alength]='\0';

        for(j=2;j<alength-1;j=j+2)
        {
            if(a[j]<b[j-1])
            {
                b[j+1]=a[j]+26-b[j-1]+'A';
            }
            else
            {
                b[j+1]=a[j]-b[j-1]+'A';
            }
        }
        for(j=alength-3;j>0;j=j-2)
        {
            if(a[j]<b[j+1])
                b[j-1]=a[j]+26-b[j+1]+'A';
            else
                b[j-1]=a[j]-b[j+1]+'A';
        }
        if(b[0]=='\0')
            fprintf(fp2,"Case #%d: AMBIGUOUS\n",i);
        else
            fprintf(fp2,"Case #%d: %s\n",i,b);
    }
    fclose(fp1);
    fclose(fp2);
    return 0;
}