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 <cstdio>
#include <cstdint>
#include <vector>
#include <utility>
#include <algorithm>
#include <queue>
#include <string>
#include <tuple>

bool includes(std::string const& s, std::string const& t) {
  // s == "ab", t == "a"  => true
  // s == "a",  t == "a"  => false
  // s == "a",  t == "ab" => false
  if (s.length() <= t.length()) return false;
  return (s.compare(0, t.length(), t) == 0);
}

std::pair<char, char> critical(std::string const& s, std::string const& t) {
  size_t n = std::min(s.length(), t.length());
  for (size_t i = 0; i <= n; ++i) {
    if (s[i] == t[i]) continue;
    if (s[i] == 0 || t[i] == 0) return {0, 0};  // no constraints
    return {s[i]-'a', t[i]-'a'};
  }
  return {0, 0};  // no constraints
}

int testcase_ends() {
  size_t n;
  scanf("%zu", &n);
  if (n == 0) return 1;

  std::vector<std::string> s(n);
  for (size_t i = 0; i < n; ++i) {
    char buf[16];
    scanf("%s", buf);
    s[i] = buf;
  }

  size_t sigma = 26;
  std::vector<std::vector<int>> g0(sigma, std::vector<int>(sigma));

  for (size_t i = 0; i < n; ++i)
    for (size_t j = i+1; j < n; ++j) {
      size_t lc, gc;
      if (includes(s[i], s[j])) return puts("no"), 0;
      std::tie(lc, gc) = critical(s[i], s[j]);
      g0[lc][gc] = 1;
    }

  std::vector<std::vector<size_t>> g(sigma);
  std::vector<size_t> indeg(sigma);
  for (size_t i = 0; i < sigma; ++i)
    for (size_t j = 0; j < sigma; ++j)
      if (i != j && g0[i][j]) {
        g[i].push_back(j);
        // fprintf(stderr, "%c -> %c\n", char(i+'a'), char(j+'a'));
        ++indeg[j];
      }

  std::queue<size_t> q;
  for (size_t i = 0; i < sigma; ++i)
    if (indeg[i] == 0) q.push(i);

  while (!q.empty()) {
    size_t v = q.front();
    // fprintf(stderr, "pop: %c\n", char(v+'a'));
    q.pop();
    for (auto u: g[v]) {
      // fprintf(stderr, "reached: %c\n", char(u+'a'));
      if (--indeg[u] == 0) q.push(u);
    }
  }

  if (*std::max_element(indeg.begin(), indeg.end()) != 0) {
    puts("no");
  } else {
    puts("yes");
  }
  return 0;
}

int main() {
  while (!testcase_ends()) {}
}

