import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.Collator;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class RoliTheCoder {
    static class EventDatabase {
        private List<Event> events;

        public EventDatabase() {
            this.events = new ArrayList<>();
        }

        public void addEvent(Event event) {
            this.events.add(event);
        }

        public boolean idExists(int eventID) {
            return events.stream().anyMatch(event -> event.getEventID() == eventID);
        }

        public boolean eventExists(String eventName, int eventID) {
            return events.stream().anyMatch(event -> event.getEventName().equals(eventName) && event.getEventID() == eventID);
        }

        public void addParticipants(List<String> participants, String eventName, int eventID) {
            this.events.stream().filter(event -> event.getEventName().equals(eventName) && event.getEventID() == eventID)
                    .forEach(event -> event.addParticipants(participants));
        }

        public void printEvents() {
            events.stream()
                    .sorted((a, b) -> {
                        int index = Integer.compare(b.getParticipantsCount(), a.getParticipantsCount());
                        index = (index != 0) ? index : lowerBeforeUpperCaseSort.compare(a.getEventName(), b.getEventName());
                        return index;
                    })
                    .forEach(event -> {
                        System.out.println(String.format("%s - %d", event.getEventName(), event.getParticipantsCount()));
                        event.printParticipants();
                    });
        }

        private Comparator<String> lowerBeforeUpperCaseSort = new Comparator<String>() {
            Collator myCollator = Collator.getInstance();

            @Override
            public int compare(String o1, String o2) {
                return myCollator.compare(o1, o2);
            }
        };
    }

    static class Event {
        private String eventName;
        private int eventID;
        private LinkedHashSet<String> participants;

        public Event(String eventName, int eventID, List<String> participants) {
            this.eventName = eventName;
            this.eventID = eventID;
            this.participants = new LinkedHashSet<>();
            this.participants.addAll(participants);
        }

        public void addParticipants(List<String> participants) {
            this.participants.addAll(participants);
        }

        public String getEventName() {
            return eventName;
        }

        public int getEventID() {
            return eventID;
        }

        public int getParticipantsCount() {
            return participants.size();
        }

        public void printParticipants() {
            participants.stream()
                    .sorted((a, b) -> lowerBeforeUpperCaseSort.compare(a, b))
                    .forEach(System.out::println);
        }

        private Comparator<String> lowerBeforeUpperCaseSort = new Comparator<String>() {
            Collator myCollator = Collator.getInstance();

            @Override
            public int compare(String o1, String o2) {
                return myCollator.compare(o1, o2);
            }
        };


    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        EventDatabase eventDatabase = new EventDatabase();
        addEvents(reader, eventDatabase);
        eventDatabase.printEvents();
    }

    private static void addEvents(BufferedReader reader, EventDatabase eventDatabase) throws IOException {
        Pattern pattern = Pattern.compile("(?<id>\\d+)\\s*#(?<event>\\w+)\\s*(?<participants>(?:@[a-zA-Z\\d'-]+\\s*)*)$");
        while (true) {
            String input = reader.readLine();
            if ("Time for Code".equals(input)) {
                break;
            }
            Matcher matcher = pattern.matcher(input);
            if (matcher.find()) {
                int id = Integer.valueOf(matcher.group("id"));
                String eventName = matcher.group("event").trim();
                List<String> participants = getParticipants(matcher);

                if (! eventDatabase.idExists(id)) {
                    Event event = new Event(eventName, id, participants);
                    eventDatabase.addEvent(event);
                } else if (eventDatabase.eventExists(eventName, id)) {
                    eventDatabase.addParticipants(participants, eventName, id);
                }

            }

        }
    }

    private static ArrayList<String> getParticipants(Matcher matcher) {
        return Arrays.stream(matcher.group("participants").split("\\s+"))
                .map(String::trim)
                .filter(e -> ! e.equals(""))
                .collect(Collectors.toCollection(ArrayList::new));
    }
}