You are given n strings. Each string consists of lowercase English letters. Rearrange (reorder) the given strings in such a way that for every string, all strings that are placed before it are its substrings.

String a is a substring of string b if it is possible to choose several consecutive letters in b in such a way that they form a. For example, string "for" is contained as a substring in strings "codeforces", "for" and "therefore", but is not contained as a substring in strings "four", "fofo" and "rof".

Input

The first line contains an integer n (1 ≤ n ≤ 100) — the number of strings.

The next n lines contain the given strings. The number of letters in each string is from 1 to 100, inclusive. Each string consists of lowercase English letters.

Some strings might be equal.

Output

If it is impossible to reorder n given strings in required order, print "NO" (without quotes).

Otherwise print "YES" (without quotes) and n given strings in required order.

Examples

Input

5
a
aba
abacaba
ba
aba


Output

YES
a
ba
aba
aba
abacaba


Input

5
a
abacaba
ba
aba
abab


Output

NO


Input

3
qwerty
qwerty
qwerty


Output

YES
qwerty
qwerty
qwerty

Note

In the second example you cannot reorder the strings because the string "abab" is not a substring of the string "abacaba".
"""Problem B - Substrings Sort.

http://codeforces.com/contest/988/problem/b

You are given `n` strings. Each string consists of lowercase English letters.
Rearrange (reorder) the given strings in such a way that for every string, all
strings that are placed before it are its substrings.

String `a` is a substring of string `b` if it is possible to choose several
consecutive letters in `b` in such a way that they form `a`. For example,
string "for" is contained as a substring in strings "codeforces", "for" and
"therefore", but is not contained as a substring in strings "four", "fofo" and
"rof".

Input:

The first line contains an integer `n` (`1 <= n <= 100`) — the number of
strings.

The next `n` lines contain the given strings. The number of letters in each
string is from `1` to `100`, inclusive. Each string consists of lowercase
English letters.

Some strings might be equal.

Output:

If it is impossible to reorder `n` given strings in required order, print "NO"
(without quotes).

Otherwise print "YES" (without quotes) and `n` given strings in required
order.

"""
import logging


fmt = '%(levelname)s - %(name)s (line:%(lineno)s) - %(message)s'
formatter = logging.Formatter(fmt)

ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
ch.setFormatter(formatter)

logger = logging.getLogger('substrings_sort')
logger.setLevel(logging.ERROR)
logger.addHandler(ch)


class SubString:
    def __init__(self, s):
        self.s = s

    def __lt__(self, other):
        if not self._check(other):
            raise Exception('Not possible')

        return self.s in other.s and len(self.s) < len(other.s)

    def __le__(self, other):
        if not self._check(other):
            raise Exception('Not possible')

        return self.s in other.s and len(self.s) == len(other.s)

    def __eq__(self, other):
        if not self._check(other):
            raise Exception('Not possible')

        return self.s == other.s
    
    def _check(self, other):
        if self.s in other.s or other.s in self.s:
            return True
        return False

    def __repr__(self):
        return self.s

def solve(seq):
    tmp = []
    for s in seq:
        tmp.append(SubString(s))
    try:
        return [x.s for x in sorted(tmp)]
    except:
        return None


def main():
    n = int(input().strip())
    seq = [input().strip() for _ in range(n)]

    result = solve(seq)
    if result:
        print('YES')
        print('\n'.join(result))
    else:
        print('NO')


if __name__ == '__main__':
    main()
