#include <bits/stdc++.h>
using namespace std;
map<string, int> string_to_id;
map<int, string> id_to_string;
vector<vector<int>> adj;
vector<int> in_degree;
vector<int> out_degree;
int get_id(const string& code) {
  if (string_to_id.count(code) == 0) {
    int size = string_to_id.size();
    string_to_id[code] = size;
    id_to_string[size] = code;
  }
  return string_to_id[code];
}
int get_char(int i) {
  if (i < 26) return 'a' + i;
  i -= 26;
  if (i < 26) return 'A' + i;
  i -= 26;
  return '0' + i;
}
template <class T>
void remove_item(std::vector<T>& coll, int item) {
  coll[item] = coll.back();
  coll.resize(coll.size() - 1);
}
int main() {
  string line;
  getline(cin, line);
  int n;
  sscanf(line.c_str(), "%d", &n);
  for (int i = 0; i < n; ++i) {
    getline(cin, line);
    int a = get_id(line.substr(0, 2));
    int b = get_id(line.substr(1, 2));
    if (adj.size() <= a) adj.resize(a + 1);
    if (adj.size() <= b) adj.resize(b + 1);
    if (in_degree.size() <= a) in_degree.resize(a + 1);
    if (out_degree.size() <= a) out_degree.resize(a + 1);
    if (in_degree.size() <= b) in_degree.resize(b + 1);
    if (out_degree.size() <= b) out_degree.resize(b + 1);
    adj[a].push_back(b);
    in_degree[b]++;
    out_degree[a]++;
  }
  int start_index = -1;
  int end_index = -1;
  int N = adj.size();
  for (int i = 0; i < N; ++i) {
    if (abs(in_degree[i] - out_degree[i]) > 1) {
      printf("NO\n");
      return 0;
    }
    if (in_degree[i] + 1 == out_degree[i]) {
      if (start_index != -1) {
        printf("NO\n");
        return 0;
      }
      start_index = i;
    }
    if (in_degree[i] == out_degree[i] + 1) {
      if (end_index != -1) {
        printf("NO\n");
        return 0;
      }
      end_index = i;
    }
  }
  if (start_index == -1) {
    start_index = 0;
    end_index = 0;
  }
  vector<vector<int>> adj_copy = adj;
  string result = id_to_string[start_index];
  vector<int> steps;
  vector<vector<int>> cycles;
  for (int i = 0; i < N; ++i) {
    while (true) {
      bool cycle_found = false;
      vector<int> visited(N);
      vector<int> processed(N);
      stack<pair<int, int>> s;
      s.push(make_pair(i, -1));
      visited[i] = true;
      while (s.size()) {
        int v = s.top().first;
        bool need_pop = true;
        while (processed[v] < adj[v].size()) {
          int u = adj[v][processed[v]];
          if (u == -1) {
            processed[v]++;
            continue;
          }
          if (visited[u]) {
            vector<int> cycle;
            cycle.push_back(u);
            int from = processed[v];
            while (s.top().first != u) {
              visited[s.top().first] = false;
              cycle.push_back(s.top().first);
              remove_item(adj[s.top().first], from);
              from = s.top().second;
              s.pop();
            }
            remove_item(adj[u], from);
            reverse(cycle.begin(), cycle.end());
            cycles.push_back(cycle);
            cycle_found = true;
            break;
          } else {
            visited[u] = true;
            s.push(make_pair(u, processed[v]));
            processed[v]++;
            need_pop = false;
            break;
          }
        }
        if (cycle_found) break;
        if (need_pop) {
          visited[s.top().first] = false;
          s.pop();
        }
      }
      if (!cycle_found) break;
    }
  }
  int C = cycles.size();
  stack<int> s_cycle;
  stack<int> s_current;
  s_current.push(start_index);
  steps.push_back(start_index);
  vector<int> processed_current(N, 0);
  vector<int> processed_cycle(C, 0);
  vector<int> visited_cycle(C);
  vector<vector<int>> vertex_to_cycle(N);
  vector<vector<int>> vertex_to_cycle_position(N);
  vector<int> processed_vertex_to_cycle(N);
  for (int i = 0; i < C; ++i) {
    for (int j = 0; j < cycles[i].size(); ++j) {
      vertex_to_cycle[cycles[i][j]].push_back(i);
      vertex_to_cycle_position[cycles[i][j]].push_back(j);
    }
  }
  while (s_current.size() || s_cycle.size()) {
    if (s_cycle.size()) {
      int c = s_cycle.top();
      bool need_pop = true;
      while (processed_cycle[c] < cycles[c].size()) {
        int v = cycles[c][processed_cycle[c]++];
        steps.push_back(v);
        while (processed_vertex_to_cycle[v] < vertex_to_cycle[v].size()) {
          int index = processed_vertex_to_cycle[v]++;
          int c = vertex_to_cycle[v][index];
          int p = vertex_to_cycle_position[v][index];
          if (visited_cycle[c]) continue;
          rotate(cycles[c].begin(), cycles[c].begin() + p + 1, cycles[c].end());
          s_cycle.push(c);
          visited_cycle[c] = true;
          need_pop = false;
          break;
        }
        if (!need_pop) break;
      }
      if (need_pop) s_cycle.pop();
    } else if (s_current.size()) {
      int v = s_current.top();
      bool go_to_cycle = false;
      while (processed_vertex_to_cycle[v] < vertex_to_cycle[v].size()) {
        int index = processed_vertex_to_cycle[v]++;
        int c = vertex_to_cycle[v][index];
        int p = vertex_to_cycle_position[v][index];
        if (visited_cycle[c]) continue;
        rotate(cycles[c].begin(), cycles[c].begin() + p + 1, cycles[c].end());
        s_cycle.push(c);
        visited_cycle[c] = true;
        go_to_cycle = true;
        break;
      }
      if (go_to_cycle) continue;
      bool need_pop = true;
      while (processed_current[v] < adj[v].size()) {
        int u = adj[v][processed_current[v]++];
        if (u == -1) continue;
        steps.push_back(u);
        s_current.push(u);
        need_pop = false;
        break;
      }
      if (need_pop) s_current.pop();
    }
  }
  if (steps.size() != n + 1) {
    printf("NO\n");
    return 0;
  }
  for (int i = 1; i < steps.size(); ++i) {
    result += id_to_string[steps[i]][1];
  }
  printf("YES\n");
  printf("%s\n", result.c_str());
  return 0;
}
