// https://szkopul.edu.pl/problemset/problem/y-mTVYClxMJcgMhUnHaUqPPq/site/

// Szablon Bajtogrodu

#include <bits/stdc++.h>

using namespace std;

#define int long long

constexpr int sizik = 1000 * 1001;

#define ar std::array
#define pr std::pair
#define vec std::vector

typedef vec<vec<int>> _kra;

constexpr int K = 27;
struct Trie {
    int next[K]{};
    std::vector<ar<int, 3>> y;
    Trie() { ; }
};

std::vector<Trie> trie;

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

std::vector<std::pair<int, char>> kra[sizik];
int depth[sizik];
int leaf = 0;

void DFS1(int v, int p, int d = 0) {
    depth[v] = d;
    int c1 = 0;
    for (const auto& [u, c] : kra[v]) {
        if (u != p) {
            DFS1(u, v, d + 1);
            c1++;
        }
    }
    if (c1 == 0) {
        leaf = v;
    }
}

void DFS3(int v, int p, const std::string& curr) {
    int c1 = 0;
    for (const auto& [u, c] : kra[v]) {
        if (u != p) {
            DFS3(u, v, (curr + c));
            c1++;
        }
    }
    if (c1 == 0) {
        add_string(curr);
    }
}

void DFS2(int v, int p, int start, int highest, int curr) {
    if (curr > 0) {
        trie[curr].y.push_back({start, v, highest});
    }

    for (const auto& [u, ch] : kra[v]) {
        if (u == p) continue;
        int c = ch - 'A';
        if (trie[curr].next[c] == 0) continue;

        int h1 = highest;
        if (depth[u] < depth[highest]) {
            h1 = u;
        }

        DFS2(u, v, start, h1, trie[curr].next[c]);
    }
}

int pref[sizik];
int n;

bool DFS4(int v, int p) {
    bool e = true;
    for (const auto& [u, ch] : kra[v]) {
        if (u != p) {
            e &= DFS4(u, v);
            pref[v] += pref[u];
        }
    }

    if (v != 1) e &= (pref[v] > 0);
    return e;
}

std::set<std::string> ans;
void DFS_check(int curr, const string& s1) {
    for (int i = 0; i <= ('Z' - 'A'); i++) {
        if (trie[curr].next[i] != 0) {
            for (int i = 1; i <= n; i++) {
                pref[i] = 0;
            }

            for (const auto& [a, b, c] : trie[trie[curr].next[i]].y) {
                pref[a]++;
                pref[b]++;
                pref[c] -= 2;
            }

            std::string s2 = s1 + (char)(i + 'A');

            bool p = DFS4(1, 1);

            if (p) {
                ans.insert(s2);
                std::reverse(s2.begin(), s2.end());
                ans.insert(s2);
            }

            DFS_check(trie[curr].next[i], (s1 + (char)(i + 'A')));
        }
    }
}

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

    for (int i = 0; i < n - 1; i++) {
        int a, b;
        char c;
        std::cin >> a >> b >> c;

        kra[a].push_back({b, c});
        kra[b].push_back({a, c});
    }

    if (n == 2) {
        std::cout << kra[1].front().second << '\n';
        return;
    }

    DFS1(1, 1, 0);
    trie.push_back({});
    DFS3(leaf, leaf, "");

    for (int i = 1; i <= n; i++) {
        DFS2(i, i, i, i, 0);
    }

    DFS_check(0, "");

    std::cout << ans.size() << '\n';
    for (const auto& a : ans) {
        std::cout << a << "\n";
    }
}

int32_t main() {
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);

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

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

    return 0;
}