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".
# -*- coding: utf-8 -*-
"""
Created on Fri Jun  1 17:26:04 2018

@author: du-wan
"""

from sys import stdin


class heap_node: 
    def __init__(self, string): 
        self.string = string
        self.size = len(string)
   
class max_heap:
    def __init__(self, vec): 
        self.maxHeap = vec
    
    def insert(self, node): 
        self.maxHeap.append(node)
        self.heapify()
        return self.maxHeap
    
    def heapify(self): 
        n = len(self.maxHeap)//2 
        for i in range(n, -1, -1):
            self.__heapify(len(self.maxHeap), i)
                
    def __heapify(self, n, i):  
        #helper method to bubble down parent and child switch nodes
        l = 2*i+1
        r = 2*i+2 
        
        largest = i
        
        if (l < n) and (self.maxHeap[l].size > self.maxHeap[largest].size): 
            largest = l 
        
        if (r < n) and (self.maxHeap[r].size  > self.maxHeap[largest].size): 
            largest = r
        
        if i != largest: 
            self.maxHeap[i], self.maxHeap[largest] = self.maxHeap[largest], self.maxHeap[i]
            self.__heapify(n, largest)
            
    def sort(self):
        self.heapify()
        sorted_vec = []
        n = len(self.maxHeap)
        for i in range(n-1, -1, -1): 
            sorted_vec.append(self.maxHeap[0])
            self.maxHeap[0], self.maxHeap[i] = self.maxHeap[i], self.maxHeap[0]
            self.__heapify(i, 0) #__heapify heapifies starting from current index up to index i
        
        return sorted_vec


def isValid(sorted_vec):
    for i in range(len(sorted_vec)-1, 0, -1): 
        if not (sorted_vec[i].string in sorted_vec[i-1].string): 
            return False
    return True    



n_strings = int(input())
string_vec = []

for _ in range(n_strings):
    string = input()
    string_vec.append(heap_node(string))

#n_strings = 5


#strings = ["a", "aba", "abacaba", "ba", "aba", "g"]
#for line in strings: 
 #   string_vec.append(heap_node(line))
    
heap = max_heap(string_vec)
sorted_vec = heap.sort()

if not isValid(sorted_vec): 
    print("NO")

else: 
    print("YES") 
    for i in range(n_strings-1, -1, -1): 
        print(sorted_vec[i].string)


