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.*;
import java.util.*;



public class B
{
	static int MOD = 1000000007;
    static Scanner in = new Scanner(System.in);
    static PrintWriter p = new PrintWriter(System.out, true);



    static int solve(){
		int n = in.nextInt();
		String[] s = new String[n];
		for (int i = 0; i < n; i++){
			s[i] = in.next();
		}
		Arrays.sort(s, (x1, x2) -> x1.length() - x2.length());
		boolean ok = true;
		for (int i = 1; i < n; i++){
			String s1 = s[i];
			String s2 = s[i - 1];
			if (!s1.contains(s2)){
				ok = false;
				break;
			}
		}
		if (ok){
			p.println("YES");
			for (int i = 0; i < n; i++){
				p.println(s[i]);
			}
		}
		else{
			p.println("NO");
		}
		p.close();
        return 0;
    }

    public static void main(String[] args)
    {
        solve();
    }
	
	static class FastReader {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt() { return Integer.parseInt(next()); }
 
        long nextLong() { return Long.parseLong(next()); }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static class F{


         static void swap(int[] a, int i, int j){
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }

        static void swap(String[] a, int i, int j){
            String temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }

        static void swap(long[] a, int i, int j){
            long temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }

        static void swap(double[] a, int i, int j){
            double temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
		
		static int[] readArrI(int N){
			int[] res = new int[N];
			for (int i = 0; i < N; i++){
				res[i] = in.nextInt();
			}
			return res;
		}
		
		static String[] readArrS(int N){
			String[] res = new String[N];
			for (int i = 0; i < N; i++){
				res[i] = in.next();
			}
			return res;
		}
		
		static double[] readArrD(int N){
			double[] res = new double[N];
			for (int i = 0; i < N; i++){
				res[i] = in.nextDouble();
			}
			return res;
		}
		
		static long[] readArrL(int N){
			long[] res = new long[N];
			for (int i = 0; i < N; i++){
				res[i] = in.nextLong();
			}
			return res;
		}
		
		static char[] readArrC(int N){
			char[] res = new char[N];
			for (int i = 0; i < N; i++){
				res[i] = in.next().charAt(0);
			}
			return res;
		}

         static int bisect_right(int[] A, int x) {
            return bisect_right(A, x, 0, A.length);
        }

         static int bisect_right(int[] A, int x, int lo, int hi) {
            int N = A.length;
            if (N == 0) {
                return 0;
            }
            if (x < A[lo]) {
                return lo;
            }
            if (x > A[hi - 1]) {
                return hi;
            }
            for (;;) {
                if (lo + 1 == hi) {
                    return lo + 1;
                }
                int mi = (hi + lo) / 2;
                if (x < A[mi]) {
                    hi = mi;
                } else {
                    lo = mi;
                }
            }
        }

        static int bisect_left(int[] A, int x) {
            return bisect_left(A, x, 0, A.length);
        }

        static int bisect_left(int[] A, int x, int lo, int hi) {
            int N = A.length;
            if (N == 0) {
                return 0;
            }
            if (x < A[lo]) {
                return lo;
            }
            if (x > A[hi - 1]) {
                return hi;
            }
            for (;;) {
                if (lo + 1 == hi) {
                    return x == A[lo] ? lo : (lo + 1);
                }
                int mi = (hi + lo) / 2;
                if (x <= A[mi]) {
                    hi = mi;
                } else {
                    lo = mi;
                }
            }
        }
    }
}
