Problem: The committee members of the Kitoshima programming contest had decided to use crypto-graphic software for their secret communication. They had asked a company, Kodai Software, to develop cryptographic software that employed a cipher based on highly sophisticated mathematics.

According to reports on IT projects, many projects are not delivered on time, on budget, with required features and functions. This applied to this case. Kodai Software failed to implement the cipher by the appointed date of delivery, and asked to use a simpler version that employed a type of substitution cipher for the moment. The committee members got angry and strongly requested to deliver the full specification product, but they unwillingly decided to use this inferior product for the moment.

In what follows, we call the text before encryption, plaintext, and the text after encryption, ciphertext.

This simple cipher substitutes letters in the plaintext, and its substitution rule is specified with a set of pairs. A pair consists of two letters and is unordered, that is, the order of the letters in the pair does not matter. A pair (A, B) and a pair (B, A) have the same meaning. In one substitution rule, one letter can appear in at most one single pair. When a letter in a pair appears in the plaintext, the letter is replaced with the other letter in the pair. Letters not specified in any pairs are left as they are.

For example, by substituting the plaintext


ABCDEFGHIJKLMNOPQRSTUVWXYZ


with the substitution rule {(A, Z), (B, Y)} results in the following ciphertext.


ZYCDEFGHIJKLMNOPQRSTUVWXBA


This may be a big chance for us, because the substitution rule seems weak against cracking. We may be able to know communications between committee members. The mission here is to develop a deciphering program that finds the plaintext messages from given ciphertext messages.

A ciphertext message is composed of one or more ciphertext words. A ciphertext word is generated from a plaintext word with a substitution rule. You have a list of candidate words containing the words that can appear in the plaintext; no other words may appear. Some words in the list may not actually be used in the plaintext.

There always exists at least one sequence of candidate words from which the given ciphertext is obtained by some substitution rule. There may be cases where it is impossible to uniquely identify the plaintext from a given ciphertext and the list of candidate words.



Input

The input consists of multiple datasets, each of which contains a ciphertext message and a list of candidate words in the following format.

n
word1
.
.
.
wordn
sequence

n in the first line is a positive integer, representing the number of candidate words. Each of the next n lines represents one of the candidate words. The last line, sequence, is a sequence of one or more ciphertext words separated by a single space and terminated with a period.

You may assume the number of characters in each sequence is more than 1 and less than or equal to 80 including spaces and the period. The number of candidate words in the list, n, does not exceed 20. Only 26 uppercase letters, A to Z, are used in the words and the length of each word is from 1 to 20, inclusive.

A line of a single zero indicates the end of the input.

Output

For each dataset, your program should print the deciphered message in a line. Two adjacent words in an output line should be separated by a single space and the last word should be followed by a single period. When it is impossible to uniquely identify the plaintext, the output line should be a single hyphen followed by a single period.

Example

Input

4
A
AND
CAT
DOG
Z XUW ZVX Z YZT.
2
AZ
AY
ZA.
2
AA
BB
CC.
16
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
ABCDEFGHIJKLMNO
A B C D E F G H I J K L M N O ABCDEFGHIJKLMNO.
0


Output

A DOG AND A CAT.
AZ.
-.
A B C D E F G H I J K L M N O ABCDEFGHIJKLMNO.

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 21

void strcpy(char* to,char* str);

struct Info{
	Info(char arg_word[NUM],int arg_length){
		strcpy(word,arg_word);
		length = arg_length;
	}
	bool operator<(const struct Info &arg) const{
		return length > arg.length;
	}
	char word[NUM];
	int length;
};


int N;
int num_finish;
int num_word[NUM];
char sequence[100];
char table[26],ans_table[26];
char plain_word[NUM][20][NUM];
vector<Info> V;


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;
}

void strcpy(char* to,char* str){
	for(int i=0;str[i] != '\0';i++){
		to[i] = str[i];
		to[i+1] = '\0';
	}
}

int getNUM(char ch){
	return ch-'A';
}

void recursive(int index){

	if(num_finish >= 2){
		return;
	}

	if(index == V.size()){

		num_finish++;
		for(int i = 0; i < 26; i++){
			ans_table[i] = table[i];
		}

		return;
	}

	int tmp_len;
	char tmp_ch;
	bool FLG,is_match;

	for(int i = index; i < V.size(); i++){

		tmp_len = V[i].length;

		FLG = false;

		for(int k = 0; k < num_word[tmp_len]; k++){

			is_match = true;
			for(int loc = 0; loc < tmp_len; loc++){

				tmp_ch = table[getNUM(V[i].word[loc])];

				if((V[i].word[loc] == plain_word[tmp_len][k][loc] && tmp_ch == '?') ||
						(tmp_ch == '?' && table[getNUM(plain_word[tmp_len][k][loc])] == '?') ||
						(tmp_ch == plain_word[tmp_len][k][loc])
						){
					continue;
				}else{
					is_match = false;
					break;
				}
			}
			if(is_match){
				FLG = true;
				break;
			}
		}
		if(!FLG){
			return;
		}
	}

	char work[26];

	tmp_len = V[index].length;

	for(int i = 0; i < num_word[tmp_len]; i++){

		for(int k = 0; k < 26; k++){
			work[k] = table[k];
		}

		is_match = true;

		for(int k = 0; k < tmp_len; k++){

			if((tmp_ch = table[getNUM(V[index].word[k])]) != '?'){

				if(tmp_ch != plain_word[tmp_len][i][k]){
					is_match = false;
					break;
				}

			}else{

				if(table[getNUM(plain_word[tmp_len][i][k])] != '?'){
					is_match = false;
					break;
				}

				table[getNUM(V[index].word[k])] = plain_word[tmp_len][i][k];
				table[getNUM(plain_word[tmp_len][i][k])] = V[index].word[k];
			}
		}

		if(is_match){
			recursive(index+1);
		}

		for(int k = 0; k < 26; k++){
			table[k] = work[k];
		}
	}
}

bool is_char(char ch){
	return ch >= 'A' && ch <= 'Z';
}

void func(){

	V.clear();

	for(int i = 0; i < NUM; i++){
		num_word[i] = 0;
	}

	char buf[NUM];
	int length;

	for(int loop = 0; loop < N; loop++){

		scanf("%s",buf);
		for(length = 0; buf[length] != '\0' && length < 81; length++);

		strcpy(plain_word[length][num_word[length]++],buf);
	}

	getchar();
	fgets(sequence,100,stdin);

	char work[NUM];
	int start,work_index;

	for(int i = 0; sequence[i] != '\0'; ){

		start = i;
		while(sequence[start] == ' ')start++;

		work_index = 0;

		while(is_char(sequence[start+work_index])){

			work[work_index] = sequence[start+work_index];
			work_index++;
		}
		work[work_index] = '\0';

		V.push_back(Info(work,work_index));

		if(sequence[start+work_index] == '.'){
			break;
		}
		i = start+work_index;
	}

	sort(V.begin(),V.end());

	for(int i = 0; i < 26; i++){
		table[i] = '?';
	}

	num_finish = 0;
	recursive(0);

	if(num_finish != 1){

		printf("-.\n");

	}else{
		int loc;

		for(int i = 0; sequence[i] != '\0' && i < 100; i++){

			if(!is_char(sequence[i])){

				printf("%c",sequence[i]);

			}else{

				loc = getNUM(sequence[i]);

				if(ans_table[loc] == '?'){ //そのまま

					printf("%c",sequence[i]);

				}else{

					printf("%c",ans_table[loc]);
				}
			}
		}
	}
}

int main(){

	while(true){
		scanf("%d",&N);
		if(N == 0)break;

		func();
	}

	return 0;
}