import java.text.Collator;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        Map<String, Team> teamsByName = new HashMap<>();
        Set<String> creators = new HashSet<>();
        Set<String> overallMembers = new HashSet<>();

        int teamSize = Integer.parseInt(sc.nextLine());

        while (teamSize-->0) {
            String[] creatorAndTeam = sc.nextLine().split("-");
            String creator = creatorAndTeam[0];
            String teamName = creatorAndTeam[1];
            if (teamsByName.containsKey(teamName)) {
                System.out.printf("Team %s was already created!%n", teamName);
                continue;
            }

            if (creators.contains(creator)) {
                System.out.printf("%s cannot create another team!%n", creator);
                continue;
            }

            Team team = new Team(teamName, creator);
            teamsByName.put(teamName, team);
            creators.add(creator);
            overallMembers.add(creator);
            System.out.printf("Team %s has been created by %s!%n", teamName, creator);
        }

        String line = sc.nextLine();

        while (!line.equalsIgnoreCase("end of assignment")) {
            String[] memberAndTeam = line.split("->");
            String member = memberAndTeam[0];
            String teamName = memberAndTeam[1];

            if (!teamsByName.containsKey(teamName)) {
                System.out.printf("Team %s does not exist!%n", teamName);
                line = sc.nextLine();
                continue;
            }

            if (overallMembers.contains(member)) {
                System.out.printf("Member %s cannot join team %s!%n", member, teamName);
                line = sc.nextLine();
                continue;
            }

            Team team = teamsByName.get(teamName);
            team.addMember(member);
            overallMembers.add(member);

            line = sc.nextLine();
        }

        teamsByName
                .entrySet()
                .stream()
                .filter(kvp -> !kvp.getValue().isDisband())
                .sorted(
                        Comparator.comparing(kvp -> ((Map.Entry<String, Team>) kvp).getValue().size())
                        .reversed()
                        .thenComparing(kvp -> ((Map.Entry<String, Team>) kvp).getKey())
               ).map(Map.Entry::getValue)
                .forEach(System.out::print);

        System.out.println("Teams to disband:");
        teamsByName
                .entrySet()
                .stream()
                .filter(kvp -> kvp.getValue().isDisband())
                .map(Map.Entry::getKey)
                .sorted()
                .forEach(System.out::println);
    }

}


class Team {
    private String name;
    private String creator;

    private Set<String> members;

    public Team(String name, String leader) {
        this.name = name;
        this.creator = leader;
        this.members = new TreeSet<>();
    }

    public String getName() {
        return this.name;
    }

    public void addMember(String member) {
        this.members.add("-- " + member + System.lineSeparator());
    }

    public boolean isDisband() {
        return this.members.size() == 0;
    }

    public int size() {
        return this.members.size();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.getName()).append(System.lineSeparator()).append("- ").append(this.creator).append(System.lineSeparator());
        this.members.forEach(sb::append);
        return sb.toString();
    }
}