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 <iostream>
#include <string>
#include <vector>
#include <map>

using namespace std;
typedef pair<int, string> pis;

int main(){
	map<int, string> base_table;
	const int SPEC_C  = 0x0001;
	const int SPEC_Cs = 0x0002;
	const int SPEC_D  = 0x0004;
	const int SPEC_Ds = 0x0008;
	const int SPEC_E  = 0x0010;
	const int SPEC_F  = 0x0020;
	const int SPEC_Fs = 0x0040;
	const int SPEC_G  = 0x0080;
	const int SPEC_Gs = 0x0100;
	const int SPEC_A  = 0x0200;
	const int SPEC_As = 0x0400;
	const int SPEC_B  = 0x0800;
	base_table.insert(pis(SPEC_C | SPEC_E | SPEC_G, ""));
	base_table.insert(pis(SPEC_C | SPEC_E | SPEC_G | SPEC_As, "7"));
	base_table.insert(pis(SPEC_C | SPEC_E | SPEC_G | SPEC_B, "M7"));
	base_table.insert(pis(SPEC_C | SPEC_Ds | SPEC_G, "m"));
	base_table.insert(pis(SPEC_C | SPEC_Ds | SPEC_G | SPEC_As, "m7"));
	multimap<int, string> spec_table;
	for(
		map<int, string>::iterator it = base_table.begin();
		it != base_table.end(); ++it)
	{
#define SPEC_INSERT(NOTE, TEXT) { \
			if(!(it->first & (NOTE))){ \
				spec_table.insert( \
					pis(it->first | (NOTE), it->second + (TEXT))); \
			} \
		}
		SPEC_INSERT(0      , "");
		SPEC_INSERT(SPEC_Cs, "(-9)");
		SPEC_INSERT(SPEC_D , "(9)");
		SPEC_INSERT(SPEC_Ds, "(+9)");
		SPEC_INSERT(SPEC_E , "(-11)");
		SPEC_INSERT(SPEC_F , "(11)");
		SPEC_INSERT(SPEC_Fs, "(+11)");
		SPEC_INSERT(SPEC_Gs, "(-13)");
		SPEC_INSERT(SPEC_A , "(13)");
		SPEC_INSERT(SPEC_As, "(+13)");
		if(!(it->first & SPEC_Fs)){
			spec_table.insert(
				pis(it->first & ~SPEC_G | SPEC_Fs, it->second + "(-5)"));
		}
		if(!(it->first & SPEC_Gs)){
			spec_table.insert(
				pis(it->first & ~SPEC_G | SPEC_Gs, it->second + "(+5)"));
		}
	}
	map<string, int> note_table;
	note_table["C"]  = 0;
	note_table["C#"] = 1;
	note_table["D"]  = 2;
	note_table["D#"] = 3;
	note_table["E"]  = 4;
	note_table["F"]  = 5;
	note_table["F#"] = 6;
	note_table["G"]  = 7;
	note_table["G#"] = 8;
	note_table["A"]  = 9;
	note_table["A#"] = 10;
	note_table["B"]  = 11;
	const char *root_table[] = {
		"C", "C#", "D", "D#", "E", "F",
		"F#", "G", "G#", "A", "A#", "B"
	};

	int N;
	cin >> N;
	while(N--){
		int M;
		cin >> M;
		int chord = 0;
		while(M--){
			string s;
			cin >> s;
			chord |= 1 << note_table[s];
		}
		vector<string> answers;
		for(int i = 0; i < 12; ++i){
			if(chord & 1){
				map<int, string>::iterator it = spec_table.find(chord);
				while(it != spec_table.end() && it->first == chord){
					answers.push_back(root_table[i] + it->second);
					++it;
				}
			}
			chord = ((chord >> 1) | (chord << 11)) & 0x0fff;
		}
		if(answers.size() == 0){
			cout << "UNKNOWN" << endl;
		}else{
			for(int i = 0; i < answers.size(); ++i){
				cout << answers[i];
				if(i == answers.size() - 1){
					cout << endl;
				}else{
					cout << " ";
				}
			}
		}
	}
	return 0;
}