While dad was at work, a little girl Tanya decided to play with dad's password to his secret database. Dad's password is a string consisting of n + 2 characters. She has written all the possible n three-letter continuous substrings of the password on pieces of paper, one for each piece of paper, and threw the password out. Each three-letter substring was written the number of times it occurred in the password. Thus, Tanya ended up with n pieces of paper.

Then Tanya realized that dad will be upset to learn about her game and decided to restore the password or at least any string corresponding to the final set of three-letter strings. You have to help her in this difficult task. We know that dad's password consisted of lowercase and uppercase letters of the Latin alphabet and digits. Uppercase and lowercase letters of the Latin alphabet are considered distinct.

Input

The first line contains integer n (1 ≤ n ≤ 2·105), the number of three-letter substrings Tanya got. 

Next n lines contain three letters each, forming the substring of dad's password. Each character in the input is a lowercase or uppercase Latin letter or a digit.

Output

If Tanya made a mistake somewhere during the game and the strings that correspond to the given set of substrings don't exist, print "NO". 

If it is possible to restore the string that corresponds to given set of substrings, print "YES", and then print any suitable password option.

Examples

Input

5
aca
aba
aba
cab
bac


Output

YES
abacaba


Input

4
abc
bCb
cb1
b13


Output

NO


Input

7
aaa
aaa
aaa
aaa
aaa
aaa
aaa


Output

YES
aaaaaaaaa
/**
 * Created by Aminul on 8/12/2018.
 */

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class CF508D {
    public static void main(String[] args)throws Exception {
        FastReader in = new FastReader(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = in.nextInt();
        reverseID = new String[2*n+1];
        List<Integer> g[] = genList(2*n+1);
        for (int i = 0; i < n; i++) {
            char s[] = in.next(3);
            int u = getId(s[0], s[1]), v = getId(s[1], s[2]);
            g[u].add(v);
        }

        List<Integer> res = Euler_Path_Cycle.eulerPathDirected(g);
        if(res == null) pw.println("NO");
        else{
            pw.println("YES");
            boolean firstChar = true;
            for(int i : res){
                if(firstChar){
                    pw.print(reverseID[i]);
                    firstChar = false;
                }
                else pw.print(reverseID[i].charAt(1));
            }
            pw.println();
        }


        pw.close();
    }

    static String reverseID[];
    static HashMap<String, Integer> map = new HashMap<>();
    static int index = 0;
    static int getId(char a, char b){
        String s = a+""+b;
        if(!map.containsKey(s)) map.put(s, ++index);
        int idx = map.get(s);
        reverseID[idx] = s;
        return idx;
    }

    static <T>List<T>[] genList(int n){
        List<T> list[] = new List[n];
        for(int i = 0; i < n; i++) list[i] = new ArrayList<T>();
        return list;
    }

    static class Euler_Path_Cycle{
        public static List<Integer> eulerPathDirected(List<Integer>[] g) {
            int n = g.length, totalEdges = 0;
            int inDegree[] = new int[n];
            int startingNode = -1;
            for (int u = 0; u < n; u++) {
                for (int v : g[u])
                    inDegree[v]++;
                if (g[u].size() > 0)
                    startingNode = u;
                totalEdges += g[u].size();
            }

            int deficit = 0;

            for (int i = 0; i < n; i++) {
                if (g[i].size() > inDegree[i]) {
                    deficit += g[i].size() - inDegree[i];
                    startingNode = i;
                }
            }

            if (deficit > 1 || startingNode == -1)
                return null;

            return eulerCycleDirected(g, startingNode, totalEdges);
        }

        public static List<Integer> eulerCycleDirected(List<Integer>[] g) {
            int n = g.length, totalEdges = 0, startingNode = -1;
            int inDegree[] = new int[n];
            for (int i = 0; i < n; i++) {
                if(g[i].size() > 0) startingNode =  i;
                for(int v : g[i]){
                    inDegree[v]++;
                }
                totalEdges += g[i].size();
            }
            for (int i = 0; i < n; i++) {
                if(inDegree[i] != g[i].size()) return null;
            }
            if(startingNode == -1) return null;
            return eulerCycleDirected(g, startingNode, totalEdges);
        }


        ////  UNDIRECTED ////
        static class Edge{
            int v, idx;
            Edge(int V, int I){
                v = V; idx = I;
            }
        }
        public static List<Integer> eulerPathUndirected(List<Edge>[] graph) {
            int u = -1, n = graph.length, edges = 0;
            for (int i = 0; i < n; i++) {
                if (graph[i].size() > 0 && graph[i].size() % 2 == 0 && u == -1) {
                    u = i;
                }
                if (graph[i].size() % 2 == 1) return null;
                edges += graph[i].size();
            }
            return eulerCycleUndirected(graph, u, edges/2);
        }

        public static List<Integer> eulerCycleUndirected(List<Edge>[] g){
            int startingNode = 0, n = g.length, totalEdges = 0;
            for (int i = 0; i < n; i++) {
                if(g[i].size() > 0 && g[i].size() % 2 == 0){
                    startingNode = i;
                }
                if(g[i].size() % 2 == 1) return null;
                totalEdges += g[i].size();
            }
            return eulerCycleUndirected(g, startingNode, totalEdges);
        }



        //auxiliary methods //
        public static List<Integer> eulerCycleUndirected(List<Edge>[] graph, int u,  int edges) {
            int[] curEdge = new int[graph.length];
            List<Integer> res = new ArrayList<>();
            Stack<Integer> stack = new Stack<>();
            stack.add(u);
            boolean vis[] = new boolean[edges];
            while (!stack.isEmpty()) {
                u = stack.pop();
                while (curEdge[u] < graph[u].size()) {
                    Edge node = graph[u].get(curEdge[u]++);
                    int v = node.v, id = node.idx;
                    if (!vis[id]) {
                        stack.push(u);
                        u = v;
                        vis[id] = true;
                    }
                }
                res.add(u);
            }

            if (res.size() != edges + 1) return null;

            Collections.reverse(res);
            return res;
        }

        public static List<Integer> eulerCycleDirected(List<Integer>[] graph, int v, int edges) {
            int[] curEdge = new int[graph.length];
            List<Integer> res = new ArrayList<>();
            Stack<Integer> stack = new Stack<>();
            stack.add(v);
            while (!stack.isEmpty()) {
                v = stack.pop();
                while (curEdge[v] < graph[v].size()) {
                    stack.push(v);
                    v = graph[v].get(curEdge[v]++);
                }
                res.add(v);
            }

            if (res.size() != edges + 1) return null;
            Collections.reverse(res);
            return res;
        }
    }

    static void debug(Object...obj) {
        System.err.println(Arrays.deepToString(obj));
    }

    static class FastReader {
        InputStream is;
        private byte[] inbuf = new byte[1024];
        private int lenbuf = 0, ptrbuf = 0;
        static final int ints[] = new int[128];

        public FastReader(InputStream is){
            for(int i='0';i<='9';i++) ints[i]=i-'0';
            this.is = is;
        }

        public int readByte(){
            if(lenbuf == -1)throw new InputMismatchException();
            if(ptrbuf >= lenbuf){
                ptrbuf = 0;
                try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
                if(lenbuf <= 0)return -1;
            }
            return inbuf[ptrbuf++];
        }

        public boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }
        public int skip() {
            int b;
            while((b = readByte()) != -1 && isSpaceChar(b));
            return b;
        }

        public String next(){
            int b = skip();
            StringBuilder sb = new StringBuilder();
            while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        public int nextInt(){
            int num = 0, b;
            boolean minus = false;
            while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
            if(b == '-'){
                minus = true;
                b = readByte();
            }

            while(true){
                if(b >= '0' && b <= '9'){
                    num = (num<<3) + (num<<1) + ints[b];
                }else{
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public long nextLong() {
            long num = 0;
            int b;
            boolean minus = false;
            while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
            if(b == '-'){
                minus = true;
                b = readByte();
            }

            while(true){
                if(b >= '0' && b <= '9'){
                    num = (num<<3) + (num<<1) + ints[b];
                }else{
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
       /* public char nextChar() {
            return (char)skip();
        }*/

        public char[] next(int n){
            char[] buf = new char[n];
            int b = skip(), p = 0;
            while(p < n && !(isSpaceChar(b))){
                buf[p++] = (char)b;
                b = readByte();
            }
            return n == p ? buf : Arrays.copyOf(buf, p);
        }

        /*private char buff[] = new char[1005];
        public char[] nextCharArray(){
            int b = skip(), p = 0;
            while(!(isSpaceChar(b))){
                buff[p++] = (char)b;
                b = readByte();
            }
            return Arrays.copyOf(buff, p);
        }*/
    }
}