from collections import defaultdict
from typing import List

def solve_user_journey_paths(input: str) -> List[str]:
    if not input or not input.strip():
        return []
    logs = []
    for line in input.split("\n"):
        if not line.strip():
            continue
        parts = line.split()
        uid, t, action = int(parts[0]), int(parts[1]), parts[2]
        logs.append((uid, t, action))
    by_user: dict = defaultdict(list)
    for uid, t, a in logs:
        by_user[uid].append((t, a))
    # Trie node: {"count": int, "children": {action: node}}
    root = {"count": 0, "children": {}}
    for uid, seq in by_user.items():
        seq.sort(key=lambda x: x[0])
        node = root
        for _, a in seq:
            ch = node["children"]
            if a not in ch:
                ch[a] = {"count": 0, "children": {}}
            ch[a]["count"] += 1
            node = ch[a]

    out: List[str] = []
    def dfs(node, depth: int):
        for action in sorted(node["children"]):
            child = node["children"][action]
            indent = " " * (2 * depth)
            prefix = "-> " if depth > 0 else ""
            out.append(f"{indent}{prefix}{action} ({child['count']})")
            dfs(child, depth + 1)
    dfs(root, 0)
    return out

import java.util.*;

class Solution {
    static class Node { int count; TreeMap<String, Node> children = new TreeMap<>(); }
    public List<String> solveUserJourneyPaths(String input) {
        List<String> out = new ArrayList<>();
        if (input == null || input.trim().isEmpty()) return out;
        Map<Integer, List<int[]>> byUserTime = new HashMap<>();
        Map<Integer, List<String>> byUserAct = new HashMap<>();
        for (String line : input.split("\n")) {
            if (line.trim().isEmpty()) continue;
            String[] p = line.trim().split("\\s+");
            int uid = Integer.parseInt(p[0]), t = Integer.parseInt(p[1]);
            byUserTime.computeIfAbsent(uid, k -> new ArrayList<>()).add(new int[]{t, byUserTime.getOrDefault(uid, new ArrayList<>()).size()});
            byUserAct.computeIfAbsent(uid, k -> new ArrayList<>()).add(p[2]);
        }
        Node root = new Node();
        for (var e : byUserTime.entrySet()) {
            int uid = e.getKey();
            List<int[]> times = e.getValue();
            List<String> acts = byUserAct.get(uid);
            Integer[] idx = new Integer[times.size()];
            for (int i = 0; i < idx.length; i++) idx[i] = i;
            Arrays.sort(idx, (a, b) -> Integer.compare(times.get(a)[0], times.get(b)[0]));
            Node node = root;
            for (int i : idx) {
                String a = acts.get(i);
                node = node.children.computeIfAbsent(a, k -> new Node());
                node.count++;
            }
        }
        dfs(root, 0, out);
        return out;
    }
    private void dfs(Node node, int depth, List<String> out) {
        for (var e : node.children.entrySet()) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < depth * 2; i++) sb.append(' ');
            if (depth > 0) sb.append("-> ");
            sb.append(e.getKey()).append(" (").append(e.getValue().count).append(")");
            out.add(sb.toString());
            dfs(e.getValue(), depth + 1, out);
        }
    }
}

#include <bits/stdc++.h>
using namespace std;

class Solution {
    struct Node { int count = 0; map<string, Node*> children; };
public:
    vector<string> solveUserJourneyPaths(string input) {
        vector<string> out;
        if (input.empty()) return out;
        map<int, vector<pair<int,string>>> byUser;
        stringstream ss(input); string line;
        while (getline(ss, line, '\n')) {
            if (line.empty()) continue;
            stringstream ls(line);
            int uid, t; string a;
            if (ls >> uid >> t >> a) byUser[uid].push_back({t, a});
        }
        Node root;
        for (auto& [uid, seq] : byUser) {
            sort(seq.begin(), seq.end());
            Node* node = &root;
            for (auto& [_t, a] : seq) {
                if (!node->children.count(a)) node->children[a] = new Node();
                node = node->children[a];
                node->count++;
            }
        }
        function<void(Node*, int)> dfs = [&](Node* n, int depth) {
            for (auto& [act, ch] : n->children) {
                string s(depth * 2, ' ');
                if (depth > 0) s += "-> ";
                s += act + " (" + to_string(ch->count) + ")";
                out.push_back(s);
                dfs(ch, depth + 1);
            }
        };
        dfs(&root, 0);
        return out;
    }
};