You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.

Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.

Input

The first line contains a positive integer k (1 ≤ k ≤ 26) — the number of strings that should be in a beautiful sequence. 

The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.

Output

If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.

If there are multiple possible answers, print any of them.

Examples

Input

1
abca


Output

YES
abca


Input

2
aaacas


Output

YES
aaa
cas


Input

4
abc


Output

NO

Note

In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
import java.io.*;
import java.util.*;

public class Task {
		
	public static void main(String[] args) throws IOException {
		new Task().solve();
	}
	
	PrintWriter out;
	int cnt = 0;
	int n;
	boolean[] used;
	int[] use;
	ArrayList<Integer>[] rg;
	ArrayList<Integer> tsort = new ArrayList<Integer>();
	int[] comp;
	int[] compsize;
	int[] mt;
	int[] a;
	int k;
	boolean[][] g;
	int dp[];
	int m;
	int[] list;
	void solve() throws IOException{
		Reader in = new Reader("input.txt");
		out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
		//out = new PrintWriter(new FileWriter(new File("output.txt"))); 
		
		int n = in.nextInt();
		String s = in.nextString();
		
		if (s.length() < n) {
			System.out.println("NO");
			return;
		}
		
		int[] a = new int[200];
		
		int cnt = 0;
		ArrayList<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < s.length(); i++)
		{
			if (a[s.charAt(i)] == 0) {
				cnt++;
				list.add(i);
			}
			a[s.charAt(i)]++;
		}
			
		if (cnt < n) {
			System.out.println("NO");
		}
		else {
			System.out.println("YES");
			for (int i = 0; i < n; i++) {
				int ind = list.get(i);
				int end = s.length();
				if (i+1 < list.size() && i < n-1) {
					end = list.get(i+1);
				}
				
				for (int j = ind; j < end;j++) {
					System.out.print(s.charAt(j));
				}
				System.out.println();
			}
		}
		
		out.flush();
		out.close();
		
	}
	

	
	long pow(int x, int m) {
		if (m == 0)
			return 1;
		return x*pow(x, m-1);
	}

}
	
	class Pair implements Comparable<Pair> {
		
		int v;
		int z;
		int i;
		
		Pair (int v, int z, int i) {
			this.v = v;
			this.z = z;
			this.i = i;
		}

		@Override
		public int compareTo(Pair p) {
			if (v > p.v)
				return 1;
			if (v < p.v)
				return -1;
			return 0;
		}
		
	}

	class Item implements Comparable<Item> {

		int v;
		int l;
		int z;
		
		Item(int v, int l, int z) {
			this.v = v;
			this.l = l;
			this.z = z;
		}
		
		@Override
		public int compareTo(Item item) {
			
			if (l > item.l)
				return 1;
			else
			if (l < item.l)
				return -1;
			else {
				if (z > item.z)
					return 1;
				else
				if (z < item.z)
					return -1;
				return 0;
			}
						
		}
		
	}
	
	class Reader {
	    
	    StringTokenizer token;
	    BufferedReader in;
	    
	    public Reader(String file) throws IOException {
	        //in = new BufferedReader( new FileReader( file ) );
	        in = new BufferedReader( new InputStreamReader( System.in ) );
	    }
	    
	    public byte nextByte() throws IOException {
	        return Byte.parseByte(Next());
	    }
	    
	    public int nextInt() throws IOException {
	        return Integer.parseInt(Next());
	    }
	    
	    public long nextLong() throws IOException {
	        return Long.parseLong(Next());
	    }
	    
	    public String nextString() throws IOException {
	        return in.readLine();
	    }
	    
	    public String Next() throws IOException {
	        while (token == null || !token.hasMoreTokens()) {
	            token = new StringTokenizer(in.readLine());
	        }
	        return token.nextToken();
	    }

	    
	}

	
