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.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.*;
public class Tester {

	public static void main(String[] args) {
		 int mod = (int) (1e9 + 7);
		 InputReader in = new InputReader(System.in);
		 PrintWriter out = new PrintWriter(System.out);

		 List<String> arr = new ArrayList<String>();
		 ArrayList<Integer> brr = new ArrayList<Integer>();
		 int n = in.nextInt();
		 //int k = in.nextInt();

		 TreeMap<Integer, String> hm1 = new TreeMap<Integer, String>();
		 HashMap<Integer, Integer> hm2 = new HashMap<Integer, Integer>();
		 boolean poss = true;
		 int max = Integer.MIN_VALUE;
		for(int i=0; i<n; i++) {
			String inp = in.nextLine();
			int size = inp.length();
			if(hm1.containsKey(size)) {
				String str = hm1.get(size);
				if(str.equals(inp))
					hm2.put(size, hm2.get(size)+1);
				else
					poss = false;
			}
			else {
				hm1.put(size, inp);
				hm2.put(size, 1);
				if(size>max)
					max = size;
			}
			
		}
		int cnt = 0;
		String one = hm1.get(hm1.firstKey());
		if(poss) {
			for(Map.Entry<Integer, String> entry : hm1.entrySet()) {
				if(entry.getKey()!=hm1.firstKey()) {
					String p = entry.getValue();
					if(!p.contains(one)) {
						poss = false;
					}
					one = p;
				}
			}
		}
		if(poss) {
			out.println("YES");
			for(Map.Entry<Integer, String> entry : hm1.entrySet()) {
				int size = entry.getKey();
				int num = hm2.get(size);
				for(int i=0;i<num;i++) {
					out.println(entry.getValue());
				}
			}
		}
		else
			out.println("NO");
		
		
		
		out.close();

	}

	static long fac(long a) {
		long k = a;
		for (long i = 2; i < a; i++) {
			k = k * i;
		}
		System.out.println(k + " " + a);

		return a;

	}

	static class Pair implements Comparable<Pair> {

		long x, y;
		int i;

		Pair(long x, long y, int i) {
			this.x = x;
			this.y = y;
			this.i = i;
		}

		@Override
		public int compareTo(Pair o) {
			if (this.x != o.x) {
				return Long.compare(this.x, o.x);
			} else {
				return Long.compare(this.y, o.y);
				// return 0;
			}
		}

		@Override
		public boolean equals(Object o) {
			if (o instanceof Pair) {
				 Pair p = (Pair) o;
				return p.x == x && p.y == y && p.i == i;
			}
			return false;
		}
	}

	public static boolean isPal(String s) {
		for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
			if (s.charAt(i) != s.charAt(j)) {
				return false;
			}
		}
		return true;
	}

	public static String rev(String s) {
		 StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		return sb.toString();
	}

	public static long gcd(long x, long y) {
		if (x % y == 0) {
			return y;
		} else {
			return gcd(y, x % y);
		}
	}

	public static int gcd(int x, int y) {
		if (x % y == 0) {
			return y;
		} else {
			return gcd(y, x % y);
		}
	}

	public static long gcdExtended(long a, long b, long[] x) {

		if (a == 0) {
			x[0] = 0;
			x[1] = 1;
			return b;
		}
		 long[] y = new long[2];
		 long gcd = gcdExtended(b % a, a, y);

		x[0] = y[1] - (b / a) * y[0];
		x[1] = y[0];

		return gcd;
	}

	public static int abs(int a, int b) {
		return Math.abs(a - b);
	}

	public static long abs(long a, long b) {
		return Math.abs(a - b);
	}

	public static int max(int a, int b) {
		if (a > b) {
			return a;
		} else {
			return b;
		}
	}

	public static int min(int a, int b) {
		if (a > b) {
			return b;
		} else {
			return a;
		}
	}

	public static long max(long a, long b) {
		if (a > b) {
			return a;
		} else {
			return b;
		}
	}

	public static long min(long a, long b) {
		if (a > b) {
			return b;
		} else {
			return a;
		}
	}

	public static long pow(long n, long p, long m) {
		long result = 1;
		if (p == 0) {
			return 1;
		}
		if (p == 1) {
			return n;
		}
		while (p != 0) {
			if (p % 2 == 1) {
				result *= n;
			}
			if (result >= m) {
				result %= m;
			}
			p >>= 1;
			n *= n;
			if (n >= m) {
				n %= m;
			}
		}
		return result;
	}

	public static long pow(long n, long p) {
		long result = 1;
		if (p == 0) {
			return 1;
		}
		if (p == 1) {
			return n;
		}
		while (p != 0) {
			if (p % 2 == 1) {
				result *= n;
			}
			p >>= 1;
			n *= n;
		}
		return result;
	}

	static class InputReader {

		private  InputStream stream;
		private  byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1) {
				throw new InputMismatchException();
			}
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch ( IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0) {
					return -1;
				}
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			 int a[] = new int[n];
			for (int i = 0; i < n; i++) {
				a[i] = nextInt();
			}
			return a;
		}

		public long[] nextLongArray(int n) {
			 long a[] = new long[n];
			for (int i = 0; i < n; i++) {
				a[i] = nextLong();
			}
			return a;
		}

		public String readString() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			 StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public String nextLine() {
			int c = snext();
			while (isSpaceChar(c)) {
				c = snext();
			}
			 StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null) {
				return filter.isSpaceChar(c);
			}
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}