#include <bits/stdc++.h>
using namespace std;
const long long ALPH = 26 * 2 + 10;
const long long MX = ALPH * ALPH;
struct Graph {
  long long indegree[MX];
  long long outdegree[MX];
  vector<pair<long long, long long>> edges;
  void clear(long long n) {
    edges.clear();
    for (long long i = 0; i < (long long)n; i++) {
      indegree[i] = outdegree[i] = 0;
    }
  }
  void addEdge(long long u, long long v) {
    indegree[v]++;
    outdegree[u]++;
    edges.push_back({u, v});
  }
  vector<long long> hierholzer(long long n, long long start = 0) {
    vector<vector<long long>> endpoint(n);
    for (long long i = 0; i < edges.size(); i++) {
      auto e = edges[i];
      long long u = e.first;
      long long v = e.second;
      endpoint[u].push_back(v);
    }
    vector<long long> curPath = {start};
    vector<long long> path;
    while (!curPath.empty()) {
      long long u = curPath.back();
      if (endpoint[u].empty()) {
        path.push_back(curPath.back());
        curPath.pop_back();
      } else {
        long long v = endpoint[u].back();
        curPath.push_back(v);
        endpoint[u].pop_back();
      }
    }
    reverse(path.begin(), path.end());
    for (long long i = 0; i < (long long)n; i++) {
      if (!endpoint[i].empty()) {
        return {};
      }
    }
    return path;
  }
  vector<long long> getEulerianCycle(long long n) {
    long long first = -1;
    for (long long u = 0; u < n; u++) {
      if (indegree[u] != outdegree[u]) {
        return {};
      }
      if (indegree[u] > 0) {
        first = u;
      }
    }
    return hierholzer(n, first);
  }
  vector<long long> getEulerianPath(long long n) {
    long long first = -1;
    long long last = -1;
    for (long long u = 0; u < n; u++) {
      if (abs(outdegree[u] - indegree[u]) >= 2) {
        return {};
      }
      if (outdegree[u] - indegree[u] == 1) {
        if (first != -1) {
          return {};
        }
        first = u;
      }
      if (indegree[u] - outdegree[u] == 1) {
        if (last != -1) {
          return {};
        }
        last = u;
      }
    }
    if (last == -1 || first == -1) {
      return {};
    }
    vector<long long> path = hierholzer(n, first);
    return path;
  }
} G;
long long transf(char c) {
  if (c >= 'a' && c <= 'z') return c - 'a';
  if (c >= 'A' && c <= 'Z') return c - 'A' + 26;
  return 52 + (c - '0');
}
long long transf(char c1, char c2) { return transf(c1) * ALPH + transf(c2); }
char inv(long long x) {
  if (x < 26) return 'a' + x;
  if (x < 52) return 'A' + x - 26;
  return '0' + x - 52;
}
pair<char, char> transfInv(long long x) {
  long long a = x / ALPH;
  long long b = x % ALPH;
  return {inv(a), inv(b)};
}
void printPath(vector<long long> &path) {
  cout << "YES\n";
  for (long long x : path) {
    cout << transfInv(x).first;
  }
  cout << transfInv(path.back()).second;
  cout << "\n";
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long q;
  cin >> q;
  for (long long i = 0; i < (long long)q; i++) {
    string s;
    cin >> s;
    G.addEdge(transf(s[0], s[1]), transf(s[1], s[2]));
  }
  vector<long long> path = G.getEulerianPath(MX);
  if (!path.empty()) {
    printPath(path);
  } else {
    vector<long long> cycle = G.getEulerianCycle(MX);
    if (!cycle.empty()) {
      printPath(cycle);
    } else {
      cout << "NO\n";
    }
  }
  return 0;
}
