Problem:
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.

Sample Input

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

Output for the Sample Input

yes
no
yes
no

Solution in Kotlin (judge verdict: Accepted)

fun main(args:Array<String>?): Unit {
    //comparator[a][b] => a.compareTo(b)
    val comparator = Array(26){IntArray(26){0}}
    while(true){
        val n = readLine()!!.trim().toInt()
        if (n == 0) return
        comparator.forEach { it.fill(0) }
        var fail = false
        val words = Array(n){readLine()!!.trim()}
        for (i in 1 until n){
            val prev = words[i - 1]
            val next = words[i]
            for (j in prev.indices){
                if (j !in next.indices){
                    fail = true
                }else if (prev[j] != next[j] && comparator[prev[j].toIndex][next[j].toIndex] == 1){
                    fail = true
                }else if (prev[j] != next[j] && comparator[prev[j].toIndex][next[j].toIndex] == 0){
                    comparator[prev[j].toIndex][next[j].toIndex] = -1
                    comparator[next[j].toIndex][prev[j].toIndex] = 1
                }
                if (j !in next.indices || prev[j] != next[j]) break
            }
        }
        if (!fail){
            outer@for (next in 1 until 26){
                for (prev in 0 until next) {
                    for (mid in 0 until 26) if (comparator[prev][mid] == comparator[mid][next] && comparator[prev][mid] != 0){
                        if (comparator[prev][next] == 0){
                            comparator[prev][next] = comparator[prev][mid]
                            comparator[next][prev] = comparator[mid][prev]
                        }else if (comparator[prev][next] != comparator[prev][mid]) {
                            fail = true
                            break@outer
                        }
                    }
                }
            }
        }
        println(
                if (fail) "no" else "yes"
        )
    }
}
val Char.toIndex: Int
        get() = this - 'a'