// https://sio2.mimuw.edu.pl/c/oi33-1/p/

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

constexpr int sizik = 4000 * 1001;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;

struct Trie {
    std::unordered_map<int, int> next;
    int ends_here = -1;
    int max_depth = 0;
    Trie() {}
};

std::vector<Trie> trie;

void add_string(const std::string& s, int idx) {
    int prev = 0;
    for (const auto& ch : s) {
        int c = ch - 'a';
        if (trie[prev].next[c] == 0) {
            trie[prev].next[c] = trie.size();
            trie.push_back({});
        }
        prev = trie[prev].next[c];
    }
    trie[prev].ends_here = idx;
}

void dfs1(int v, int p, int d) {
    trie[v].max_depth = d;
    for (const auto& [c, u] : trie[v].next) {
        if (u == p) continue;
        dfs1(u, v, d + 1);
        trie[v].max_depth = std::max(trie[v].max_depth, trie[u].max_depth);
    }
}

std::vector<int> kol;

void dfs2(int v, int p) {
    if (trie[v].ends_here != -1) {
        kol.push_back(trie[v].ends_here);
    }
    std::vector<int> children;
    for (const auto& [c, u] : trie[v].next) {
        children.push_back(u);
    }
    std::sort(children.begin(), children.end(), [](int a, int b) { return trie[a].max_depth < trie[b].max_depth; });
    for (const auto& u : children) {
        if (u == p) continue;
        dfs2(u, v);
    }
}

int lcp(const std::string& a, const std::string& b) {
    int l = std::min(a.size(), b.size());
    int i = 0;

    while (i < l && a[i] == b[i]) {
        i++;
    }

    return i;
}

void solve() {
    int n;
    std::cin >> n;

    trie.push_back({});

    std::vector<std::string> v(n);
    for (int i = 0; i < n; i++) {
        std::cin >> v[i];
        add_string(v[i], i);
    }

    dfs1(0, 0, 0);
    dfs2(0, 0);

    std::string ans;
    ans += v[kol[0]] + 'E';
    for (int i = 1; i < n; i++) {
        int l = lcp(v[kol[i - 1]], v[kol[i]]);

        int cost1 = (int)v[kol[i]].size();

        const int B_cnt = (int)v[kol[i - 1]].size() - l;
        int cost2 = 1 + B_cnt + (int)v[kol[i]].size() - l;

        if (cost1 <= cost2) {
            ans += v[kol[i]] + 'E';
        } else {
            ans += 'T';
            for (int j = 0; j < B_cnt; j++) {
                ans += 'B';
            }
            for (int j = l; j < (int)v[kol[i]].size(); j++) {
                ans += v[kol[i]][j];
            }
            ans += 'E';
        }
    }

    std::cout << ans.size() << '\n';
    std::cout << ans << '\n';
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}