#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
#include <map>


class Graph{
public:
    void new_word(const std::string& word) {
        Vertex* prev = nullptr;
        std::string temp = "aaa";
        for(size_t i = 0; i < word.size() - 2; ++i) {
            temp[0] = word[i];
            temp[1] = word[i + 1];
            temp[2] = word[i + 2];

            if(vertexes_.find(temp) == vertexes_.end()) {
                auto v_new = new Vertex(temp);
                vertexes_.emplace(temp, v_new);
                if(prev != nullptr) {
                    prev->addEdge(v_new);
                }
                prev = v_new;
            }
            else {
                if(prev != nullptr) {
                    prev->addEdge(vertexes_[temp]);
                }
                prev = vertexes_[temp];
            }
        }
    }

    void print_size() {
        std::cout << vertexes_.size() << std::endl;
    }

    void print_edges() {
        std::vector<Vertex::Edge*> edges;
        for(auto v: vertexes_) {
            for(auto e: v.second->edges) {
                edges.push_back(e);
            }
        }

        std::cout << edges.size() << std::endl;
        for(auto e: edges) {
            std::cout << e->begin->triple << ' ' << e->end->triple << ' ' << e->count << std::endl;
        }
    }
private:
    struct Vertex{
        struct Edge{
            Vertex* begin;
            Vertex* end;
            size_t count;

            Edge() = default;
        };

        std::string triple;
        std::vector<Edge*> edges;

        Vertex() = default;
        explicit Vertex(const std::string& word): triple(word)
        {}

        void addEdge(Vertex* end) {
            size_t it = 0;
            for(; it < edges.size(); it++) {
                if(edges[it]->end == end) {
                    break;
                }
            }
            if(it == edges.size()) {
                auto e = new Edge{this, end, 1};
                edges.push_back(e);
            }
            else{
                edges[it]->count++;
            }
        }
    };

    std::map<std::string, Vertex*> vertexes_;
};


int main() {
    int n;
    std::cin >> n;
    std::string input;
    Graph g;

    for(int i = 0; i < n; ++i) {
        std::cin >> input;
        g.new_word(input);
    }

    g.print_size();
    g.print_edges();
}