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
import java.util.List;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.ArrayList;
import java.util.Vector;
import java.util.Set;
import java.util.Iterator;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.LinkedList;
import java.util.HashSet;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    static int R = 122 - 48 + 1;
    static int inDegree[];
    static int outDegree[] = new int[R * R];
    private Graph G;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        long t1 = System.currentTimeMillis();
        int N = in.nextInt();
        G = new Graph(R * R);
        inDegree = new int[R * R];
        outDegree = new int[R * R];
        Set<String> set = new HashSet<>();
        for (int i = 0; i < N; i++) {
            String tmp = in.next();
            String from = tmp.substring(0, 2);
            String to = tmp.substring(1);
            set.add(from);
            set.add(to);
            G.addEdge(from, to);
        }
        int nodeCount = set.size();
        List<Integer> oddVertices = new ArrayList<>();
        for (int i = 0; i < R * R; i++) {
            if ((inDegree[i] + outDegree[i]) % 2 != 0) {
                oddVertices.add(i);
            }
        }

        if ((oddVertices.size() != 0 && oddVertices.size() != 2) || !isConnected(nodeCount)) {
            out.println("NO");
            return;
        }


        int start = -1;
        if (oddVertices.size() == 2) {
            if (outDegree[oddVertices.get(0)] == inDegree[oddVertices.get(0)] + 1) {
                start = oddVertices.get(0);
            } else if (outDegree[oddVertices.get(1)] == inDegree[oddVertices.get(1)] + 1) {
                start = oddVertices.get(1);
            } else {
                out.println("NO");
                return;
            }
        } else {
            for (int i = 0; i < R * R; i++) {
                if (inDegree[i] != outDegree[i]) {
                    out.println("NO");
                    return;
                }
            }
            start = idx(set.iterator().next());
        }

        Stack<String> eulerTour = new Stack<>();
        Stack<Integer> stack = new Stack<>();
        stack.push(start);
        find(eulerTour, stack);
        StringBuilder sb = new StringBuilder();
        int cnt = 0;
        while (!eulerTour.isEmpty()) {
            String s = eulerTour.pop();
            if (cnt == 0) {
                sb.append(s);
            } else {
                sb.append(s.substring(1));
            }
            cnt++;
        }
        out.println("YES");
        out.println(sb);
    }

    private void find(Stack<String> eulerTour, Stack<Integer> stack) {
        Iterator<Integer>[] adj = (Iterator<Integer>[]) new Iterator[G.V];
        for (int v = 0; v < G.V; v++)
            adj[v] = G.adj[v].iterator();
        while (!stack.isEmpty()) {
            int v = stack.pop();
            boolean noMoreEdges = true;
            while (adj[v].hasNext()) {
                noMoreEdges = false;
                stack.push(v);
                stack.push(adj[v].next());
                break;
            }
            if (noMoreEdges) {
                eulerTour.push(word(v));
            }
        }
    }

    private boolean isConnected(int nodeCount) {
        UF uf = new UF(R * R);
        for (int v = 0; v < G.V; v++) {
            for (Integer w : G.adj[v]) {
                uf.union(v, w);
            }
        }
        return nodeCount == R * R - uf.count + 1;
    }


    private static int idx(String word) {
        return R * toInt(word.charAt(0)) + toInt(word.charAt(1));
    }

    private static int toInt(char c) {
        return c - 48;
    }

    private static char toChar(int x) {
        return (char) (x + 48);
    }

    private static String word(int idx) {
        char first = toChar(idx / R);
        char second = toChar(idx % R);
        return new String(new char[]{first, second});
    }

    private static class Graph {
        int V = 0;
        List<Integer> adj[];


        public Graph(int n) {
            this.V = n;
            adj = (List<Integer>[]) new LinkedList[n];
            for (int v = 0; v < n; v++) {
                adj[v] = new LinkedList<>();
            }
        }

        public void addEdge(String from, String to) {
            int idxFrom = idx(from);
            int idxTo = idx(to);
            outDegree[idxFrom]++;
            inDegree[idxTo]++;
            adj[idxFrom].add(idxTo);
        }
    }

    private static class UF {
        private int count;
        private int id[];
        private int sz[];

        public UF(int N) {
            this.count = N;
            this.id = new int[N];
            this.sz = new int[N];
            for (int i = 0; i < N; i++) {
                id[i] = i;
                sz[i] = 1;
            }
        }

        public int find(int p) {
            while (p != id[p]) {
                p = id[p];
                id[p] = id[id[p]];
            }
            return p;
        }

        public void union(int p, int q) {
            int pId = find(p);
            int qId = find(q);
            if (pId == qId) return;

            if (sz[pId] > sz[qId]) {
                id[qId] = pId;
                sz[pId] += sz[qId];
            } else {
                id[pId] = qId;
                sz[qId] += sz[pId];
            }
            count--;
        }
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }
}

