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".
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
//ArrayList<Integer> list = new ArrayList<Integer>();
import java.util.Collections;
import java.util.StringTokenizer;
public class LOL {	
	public static void main(String[] args) throws IOException{
		Scanner sc=new Scanner(System.in);
	   int n=sc.nextInt();
	   String m[]=new String[n];
	   for(int i=0 ; i<n ; i++) {
		   m[i]=sc.nextLine();
	   }
	   sortStrWithLam(m);
	  	boolean flag=true;
	   for(int i=0 ; i<n-1 ; i++) {
		   if(m[i+1].contains(m[i])==false) {
			   flag=false;
			   break;
		   }
	   }
	  
	   if(flag) {
		   System.out.println("YES");
	  
		  for(int i=0 ; i<n ; i++) {
			  System.out.println(m[i]);
		  }
	   
	   }
	   else {
		   System.out.println("NO");
	   }
	   
          
          
          
	   


	    	
	}

	public static String[] sortStrWithLam(String[] array){
	    //sort arrays by length before returning
	    Arrays.sort(array,(a,b) -> Integer.compare(a.length(),b.length()));
	    return array;
	}

	
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public int[] nextIntArr(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++)
				arr[i] = nextInt();
			return arr;
		}

		public long[] nextLongArr(int n) throws IOException {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++)
				arr[i] = nextLong();
			return arr;
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}
	}
}