Problem: In this problem, you are required to write a program that enumerates all chord names for given tones.

We suppose an ordinary scale that consists of the following 12 tones:

C, C# , D, D# , E, F, F# , G, G# , A, A# , B

Two adjacent tones are different by a half step; the right one is higher. Hence, for example, the tone G is higher than the tone E by three half steps. In addition, the tone C is higher than the tone B by a half step. Strictly speaking, the tone C of the next octave follows the tone B, but octaves do not matter in this problem.

A chord consists of two or more different tones, and is called by its chord name. A chord may be represented by multiple chord names, but each chord name represents exactly one set of tones.

In general, a chord is represented by a basic chord pattern (base chord) and additional tones (tension) as needed. In this problem, we consider five basic patterns as listed below, and up to one additional tone.

<image>

Figure 1: Base chords (only shown those built on C)

The chords listed above are built on the tone C, and thus their names begin with C. The tone that a chord is built on (the tone C for these chords) is called the root of the chord.

A chord specifies its root by an absolute tone, and its other components by tones relative to its root. Thus we can obtain another chord by shifting all components of a chord. For example, the chord name D represents a chord consisting of the tones D, F# and A, which are the shifted-up tones of C, E and G (which are components of the chord C) by two half steps.

An additional tone, a tension, is represented by a number that may be preceding a plus or minus sign, and designated parentheses after the basic pattern. The figure below denotes which number is used to indicate each tone.

<image>

Figure 2: Tensions for C chords

For example, C(9) represents the chord C with the additional tone D, that is, a chord that consists of C, D, E and G. Similarly, C(+11) represents the chord C plus the tone F#.

The numbers that specify tensions denote relative tones to the roots of chords like the compo- nents of the chords. Thus change of the root also changes the tones specified by the number, as illustrated below.

<image>

Figure 3: Tensions for E chords

+5 and -5 are the special tensions. They do not indicate to add another tone to the chords, but to sharp (shift half-step up) or flat (shift half-step down) the fifth tone (the tone seven half steps higher than the root). Therefore, for example, C(+5) represents a chord that consists of C, E and G# , not C, E, G and G#.

Figure 4 describes the syntax of chords in Backus-Naur Form.

Now suppose we find chord names for the tones C, E and G. First, we easily find the chord C consists of the tones C, E and G by looking up the base chord table shown above. Therefore ‘C’ should be printed. We have one more chord name for those tones. The chord Em obviously represents the set of tones E, G and B. Here, if you sharp the tone B, we have the set of tones E, G and C. Such modification can be specified by a tension, +5 in this case. Thus ‘Em(+5)’ should also be printed.

<image>

Figure 4: Syntax of chords in BNF



Input

The first line of input contains an integer N, which indicates the number of test cases.

Each line after that contains one test case. A test case consists of an integer m (3 ≤ m ≤ 5) followed by m tones. There is exactly one space character between each tones. The same tone does not appear more than once in one test case.

Tones are given as described above.

Output

Your program should output one line for each test case.

It should enumerate all chord names that completely match the set of tones given as input (i.e. the set of tones represented by each chord name must be equal to that of input) in any order.

No chord name should be output more than once. Chord names must be separated by exactly one space character. No extra space is allowed.

If no chord name matches the set of tones, your program should just print ‘UNKNOWN’ (note that this word must be written in capital letters).

Example

Input

5
3 C E G
3 C E G#
4 C A G E
5 F A C E D
3 C D E


Output

C Em(+5)
C(+5) E(+5) G#(+5)
C(13) Am7 Am(+13)
Dm7(9) FM7(13)
UNKNOWN

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 12

struct Info{
	Info(int arg_tone_id,int arg_code_id,int arg_tension_op,int arg_tension_value,bool arg_is_tension){
		tone_id = arg_tone_id;
		code_id = arg_code_id;
		tension_op = arg_tension_op;
		tension_value = arg_tension_value;
		is_tension = arg_is_tension;
	}
	int tone_id,code_id,tension_op,tension_value;
	bool is_tension;
};

int POW[NUM];
int tension_array[4] = {9,11,13,5};
int diff_table[3][3] = {{1,2,3},{4,5,6},{8,9,10}};
char tone_name[NUM][3] = {"C","C#","D","D#","E","F","F#","G","G#","A","A#","B"};
char code_name[NUM][3] = {"@","7","M7","m","m7"};
vector<int> component[5];
vector<Info> ANS;

bool strCmp(char* base, char* comp){
	int length1,length2;
	for(length1=0;base[length1] != '\0';length1++);
	for(length2=0;comp[length2] != '\0';length2++);
	if(length1 != length2)return false;

	for(int i=0;base[i] != '\0'; i++){
		if(base[i] != comp[i])return false;
	}
	return true;
}

//該当するtoneのidを返却する
int get_id(char buf[3]){

	for(int i = 0; i < NUM; i++){
		if(strCmp(tone_name[i],buf)){
			return i;
		}
	}

	return -1;
}

int get_state(bool check[NUM]){

	int ret = 0;

	for(int i = 0; i < NUM; i++){
		if(check[i]){
			ret += POW[i];
		}
	}

	return ret;
}

void print_Info(Info info){

	printf("%s",tone_name[info.tone_id]);

	if(info.code_id != 0){

		printf("%s",code_name[info.code_id]);
	}
	if(!info.is_tension)return;

	printf("(");

	if(info.tension_op != 0){

		if(info.tension_op > 0){

			printf("+");

		}else{

			printf("-");
		}
	}
	printf("%d",info.tension_value);
	printf(")");
}

void dfs(int ans_state){

	int tmp,tmp_state,tmp_value,diff,tmp_loc;
	bool check[12],pre;

	for(int base_tone = 0; base_tone < NUM; base_tone++){
		for(int cord = 0; cord < 5; cord++){

			for(int i = 0; i < NUM; i++){
				check[i] = false;
			}
			for(int i = 0; i < component[cord].size(); i++){
				check[(base_tone+component[cord][i])%12] = true;
			}

			tmp_state = get_state(check);

			if(tmp_state == ans_state){
				ANS.push_back(Info(base_tone,cord,0,0,false)); //テンション無しで見つかればcontinue
				continue;
			}

			//テンションを全探索
			for(int t = 0; t < 4; t++){

				tmp_value = tension_array[t];

				if(tmp_value != 5){
					//各数字について、マイナス、ノーマル、プラスの3つ
					for(int a = 0; a < 3; a++){

						diff = diff_table[t][a]; //base_toneからの相対位置
						tmp_loc = (base_tone+diff)%12;
						pre = check[tmp_loc];
						check[tmp_loc] = true;
						tmp_state = get_state(check);
						if(tmp_state == ans_state){
							ANS.push_back(Info(base_tone,cord,a-1,tmp_value,true));
						}
						check[tmp_loc] = pre;
					}

				}else{ //tmp_value == 5

					//★base_toneより7半音高い音を上下させる
					tmp_loc = (base_tone+7)%12;
					check[tmp_loc] = false;

					//マイナス
					pre = check[(tmp_loc+11)%12];
					check[(tmp_loc+11)%12] = true; //-1の代わりに11
					tmp_state = get_state(check);
					if(tmp_state == ans_state){
						ANS.push_back(Info(base_tone,cord,-1,tmp_value,true));
					}
					check[(tmp_loc+11)%12] = pre;

					//プラス
					pre = check[(tmp_loc+1)%12];
					check[(tmp_loc+1)%12] = true;
					tmp_state = get_state(check);
					if(tmp_state == ans_state){
						ANS.push_back(Info(base_tone,cord,1,tmp_value,true));
					}
					check[(tmp_loc+1)%12] = pre;

					check[tmp_loc] = true;
				}
			}
		}
	}
}


void func(){

	int num;
	char buf[3];

	scanf("%d",&num);

	int tmp_state = 0;

	for(int loop = 0; loop < num; loop++){
		scanf("%s",buf);
		tmp_state += POW[get_id(buf)];
	}

	ANS.clear();

	dfs(tmp_state);

	if(ANS.size() == 0){
		printf("UNKNOWN\n");
		return;
	}

	print_Info(ANS[0]);
	for(int i = 1; i < ANS.size(); i++){
		printf(" ");
		print_Info(ANS[i]);
	}

	printf("\n");
}


int main(){

	//何もなし
	component[0].push_back(0);
	component[0].push_back(4);
	component[0].push_back(7);

	//7
	component[1].push_back(0);
	component[1].push_back(4);
	component[1].push_back(7);
	component[1].push_back(10);

	//M7
	component[2].push_back(0);
	component[2].push_back(4);
	component[2].push_back(7);
	component[2].push_back(11);

	//m
	component[3].push_back(0);
	component[3].push_back(3);
	component[3].push_back(7);

	//m7
	component[4].push_back(0);
	component[4].push_back(3);
	component[4].push_back(7);
	component[4].push_back(10);


	POW[0] = 1;
	for(int i = 1; i < NUM; i++){
		POW[i] = POW[i-1]*2;
	}
	int num_case;

	scanf("%d",&num_case);

	for(int loop = 0; loop < num_case; loop++){
		func();
	}

	return 0;
}