Problem Statement

We found a dictionary of the Ancient Civilization Mayo (ACM) during excavation of the ruins. After analysis of the dictionary, we revealed they used a language that had not more than 26 letters. So one of us mapped each letter to a different English alphabet and typed all the words in the dictionary into a computer.

How the words are ordered in the dictionary, especially whether they are ordered lexicographically, is an interesting topic to many people. As a good programmer, you are requested to write a program to judge whether we can consider the words to be sorted in a lexicographical order.

Note: In a lexicographical order, a word always precedes other words it is a prefix of. For example, `ab` precedes `abc`, `abde`, and so on.



Input

The input consists of multiple datasets. Each dataset is formatted as follows:


n
string_1
...
string_n


Each dataset consists of n+1 lines. The first line of each dataset contains an integer that indicates n (1 \leq n \leq 500). The i-th line of the following n lines contains string_i, which consists of up to 10 English lowercase letters.

The end of the input is `0`, and this should not be processed.

Output

Print either `yes` or `no` in a line for each dataset, in the order of the input. If all words in the dataset can be considered to be ordered lexicographically, print `yes`. Otherwise, print `no`.

Example

Input

4
cba
cab
b
a
3
bca
ab
a
5
abc
acb
b
c
c
5
abc
acb
c
b
b
0


Output

yes
no
yes
no
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;

string s[500], t[500];
vector<int>E[26];
int in[26], d[26], p;
bool used[26];
int main() {
	int n;
	while (scanf("%d", &n), n) {
		memset(used, 1, sizeof(used));
		memset(in, 0, sizeof(in));
		rep(i, 26)E[i].clear();
		rep(i, n) {
			cin >> s[i]; t[i] = s[i];
			for (char c : s[i])used[c - 'a'] = false;
		}
		rep(i, 10) {
			rep(j, n)for (int k = j + 1; k < n; k++) {
				if (i < s[j].size() && i < s[k].size() && s[j][i] != s[k][i] && s[j].substr(0, i) == s[k].substr(0, i)) {
					in[s[k][i] - 'a']++; E[s[j][i] - 'a'].push_back(s[k][i] - 'a');
				}
			}
		}
		queue<int>Q;
		p = 0;
		rep(i, 26) {
			if (!in[i] && !used[i])Q.push(i);
			while (!Q.empty()) {
				int u = Q.front(); Q.pop();
				used[u] = true; d[u] = p++;
				for (int v : E[u]) {
					in[v]--; if (!in[v])Q.push(v);
				}
			}
		}
		rep(i, 26) {
			if (!used[i]) {
				puts("no"); goto g;
			}
		}
		sort(t, t + n, [&](string a, string b) {
			rep(i, min(a.size(), b.size())) {
				if (a[i] != b[i])return d[a[i] - 'a'] < d[b[i] - 'a'];
			}
			return a.size() < b.size();
		});
		rep(i, n) {
			if (s[i] != t[i]) {
				puts("no"); goto g;
			}
		}
		puts("yes");
	g:;
	}
}