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


//   @TIRTH SHAH   
     
     
    public class B implements Runnable {

        
        public void run() {
           
            final InputReader sc = new InputReader(System.in);
            final PrintWriter out = new PrintWriter(System.out);
           
            int k=sc.nextInt();
            String s=sc.next();
            char c[]=s.toCharArray();
            HashSet<Character> s1=new HashSet<Character>();
            int extra=1,final1=0;
            if(k>c.length)
            {
                out.println("NO");
            }
            else
            {
                for(int i=0;i<c.length;i++)
                {
                    s1.add(c[i]);
                }
                if(k<=s1.size())
                {
                    ArrayList<Character > list=new ArrayList<Character>();
                    list.add(c[0]);
                    out.println("YES");
                    out.print(c[0]);
                    for(int i=1;i<c.length;i++)
                    {
                            if(list.contains(c[i]) && extra<k)
                            {
                                    out.print(c[i]);

                            }
                            else if (extra<k)
                            {
                                 list.add(c[i]);
                                 out.println();
                                 extra++;
                                 out.print(c[i]);
                                 
                            }
                            else
                            {
                                out.print(c[i]);
                            }

                    }
                }
                else
                {
                    out.println("NO");
                }

            }
            

            out.close();
        
        
            
            
            }
     
    //========================================================
     
        static class Pair
        {
            int a,b;
            Pair(final int aa,final int bb)
            {
                a=aa;
                b=bb;
            }
        }
        
        static void sa(final int a[],final InputReader sc)
        {
            for(int i=0;i<a.length;i++)
            {
                a[i]=sc.nextInt();
            }
            Arrays.sort(a);
        }
     
        static class InputReader {
            private final InputStream stream;
            private final byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
            private final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     
            public InputReader(final InputStream stream) {
                this.stream = stream;
            }
           
            public int read() {
                if (numChars==-1)
                    throw new InputMismatchException();
               
                if (curChar >= numChars) {
                    curChar = 0;
                    try {
                        numChars = stream.read(buf);
                    }
                    catch (final IOException e) {
                        throw new InputMismatchException();
                    }
                   
                    if(numChars <= 0)              
                        return -1;
                }
                return buf[curChar++];
            }
         
            public String nextLine() {
                String str = "";
                try {
                    str = br.readLine();
                }
                catch (final IOException e) {
                    e.printStackTrace();
                }
                return str;
            }
            public int nextInt() {
                int c = read();
               
                while(isSpaceChar(c))
                    c = read();
               
                int sgn = 1;
               
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
               
                int res = 0;
                do {
                    if(c<'0'||c>'9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
               
                return res * sgn;
            }
           
            public long nextLong() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                long res = 0;
               
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
                    return res * sgn;
            }
           
            public double nextDouble() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.') {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.') {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c)) {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }
           
            public String readString() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                final StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = read();
                }
                while (!isSpaceChar(c));
               
                return res.toString();
            }
         
            public boolean isSpaceChar(final int c) {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }
         
            public String next() {
                return readString();
            }
           
            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
        }
     
        public static void main(final String args[]) throws Exception {
            new Thread(null, new B(),"Main",1<<27).start();
        }
    } 