package setsAndMaps;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;
import java.util.Set;
import java.util.StringJoiner;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.TreeSet;

public class ChatSystemTest {

    public static void main(String[] args)
            throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, NoSuchRoomException {
        Scanner jin = new Scanner(System.in);
        int k = jin.nextInt();
        if (k == 0) {
            ChatRoom cr = new ChatRoom(jin.next());
            int n = jin.nextInt();
            for (int i = 0; i < n; ++i) {
                k = jin.nextInt();
                if (k == 0)
                    cr.addUser(jin.next());
                if (k == 1)
                    cr.removeUser(jin.next());
                if (k == 2)
                    System.out.println(cr.hasUser(jin.next()));
            }
            System.out.println("");
            System.out.println(cr.toString());
            n = jin.nextInt();
            if (n == 0)
                return;
            ChatRoom cr2 = new ChatRoom(jin.next());
            for (int i = 0; i < n; ++i) {
                k = jin.nextInt();
                if (k == 0)
                    cr2.addUser(jin.next());
                if (k == 1)
                    cr2.removeUser(jin.next());
                if (k == 2)
                    cr2.hasUser(jin.next());
            }
            System.out.println(cr2.toString());
        }
        if (k == 1) {
            ChatSystem cs = new ChatSystem();
            Method mts[] = cs.getClass().getMethods();
            while (true) {
                String cmd = jin.next();
                if (cmd.equals("stop"))
                    break;
                if (cmd.equals("print")) {
                    System.out.println(cs.getRoom(jin.next()) + "\n");
                    continue;
                }
                for (Method m : mts) {
                    if (m.getName().equals(cmd)) {
                        String params[] = new String[m.getParameterTypes().length];
                        for (int i = 0; i < params.length; ++i)
                            params[i] = jin.next();
                        m.invoke(cs, params);
                    }
                }
            }
        }
    }
}

class NoSuchRoomException extends Exception{
    public NoSuchRoomException(String s) {
        super(s);
    }
}

class NoSuchUserException extends Exception{
        public NoSuchUserException(String userName){
            super(userName);
    }
}

class ChatRoom implements Comparable<ChatRoom> {
    private String name;
    private Set<String> users;

    public ChatRoom(String n) {
        name = n;
        users = new TreeSet<>();
    }

    public void addUser(String name) {
        users.add(name);
    }

    public void removeUser(String username) {
        users.remove(username);
    }

    @Override
    public String toString() {
        StringJoiner sj = new StringJoiner("\n");
        sj.add(name);
        for (String string : users) {
            sj.add(string);
        }
        return sj.toString();
    }

    public boolean hasUser(String username) {
        return users.contains(username);
    }

    public int numUsers() {
        return users.size();
    }

    @Override
    public int compareTo(ChatRoom o) {
        return name.compareTo(o.name);
    }

    public int getSize(){
        return users.size();
    }

    public String getName() {
        return name;
    }

    public boolean contains(String name){
        return users.contains(name);
    }

}

class ChatSystem{
    private Map<String, ChatRoom> rooms;
    private Set<String> names;

    public ChatSystem() {
        rooms = new TreeMap<>();
        names = new HashSet<>();
    }

    public void addRoom(String roomName){
        rooms.put(roomName, new ChatRoom(roomName));
    }
    public ChatRoom getRoom(String roomName) throws NoSuchRoomException{
        ChatRoom room = rooms.get(roomName);
        if(room==null){
            throw new NoSuchRoomException(roomName);
        }
        return room;
    }
    //to implement
    public void register(String userName){
        names.add(userName);
        String nameOfRoom = findRoom(rooms);
        ChatRoom room = rooms.get(nameOfRoom);
        room.addUser(userName);
    }

    //find name of room with minimum users
    private String findRoom(Map<String,ChatRoom> rooms){
        List<String> listRooms = new ArrayList<>();
        int max = Integer.MIN_VALUE;
        String name="";
        for(Map.Entry<String,ChatRoom> entry: rooms.entrySet()){
            ChatRoom ch = entry.getValue();
            int size = ch.getSize();
            if(size>max){
                max = size;
                 name = ch.getName();
            }
        }
        return name;
    }

    public void registerAndJoin(String userName,String roomName) throws NoSuchRoomException{
        names.add(userName);
        ChatRoom room = rooms.get(roomName);
        if(room == null){
            throw new NoSuchRoomException(roomName);
        }

        room.addUser(userName);

    }

    public void joinRoom(String username,String roomName) throws NoSuchRoomException{
        ChatRoom room = rooms.get(roomName);
        if(room == null){
            throw new NoSuchRoomException(roomName);
        }
        room.addUser(username);
        names.add(username);
    }
    public void leaveRoom(String username,String roomName) throws NoSuchRoomException, NoSuchUserException{
        ChatRoom room = rooms.get(roomName);
        if(room == null){
            throw new NoSuchRoomException(roomName);
        }
        if(!names.contains(username)){
            throw new NoSuchUserException(username);
        }
        room.removeUser(username);
    }

    public void followFriend(String username, String friendUsername) throws NoSuchUserException{

        if(!names.contains(friendUsername)){
            throw new NoSuchUserException(friendUsername);
        }
        for(Map.Entry<String, ChatRoom> entry:rooms.entrySet()){
            ChatRoom room = entry.getValue();
            if(room.contains(friendUsername)){
                room.addUser(username);
            }
        }

    }
}