import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Set;
import java.util.Comparator;

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 ChatRoom {
    private String roomName;
    private TreeSet<String> users;

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public ChatRoom(String name) {
        roomName = name;
        users = new TreeSet();
    }

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

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

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(roomName + "\n");
        Iterator<String> it = users.iterator();
        if (users.isEmpty())
            sb.append("EMPTY" + "\n");
        else {
            while (it.hasNext()) {
                sb.append(it.next() + "\n");
            }

        }
        return sb.toString();
    }

    public boolean hasUser(String username) {
        if (users.contains(username)) {
            return true;
        } else {
            return false;
        }
    }

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

    public String getName() {
        return roomName;
    }

}
 class ChatSystem {
    private TreeMap<String, ChatRoom> rooms;
    private HashMap<String, ArrayList<String>> allUsers;

    public ChatSystem() {
        rooms = new TreeMap<>();
        allUsers = new HashMap<>();
    }

    public void register(String userName) {
        if (rooms.isEmpty()) // ako nema chatRoom vo sistemot
        {
            ArrayList<String> usersList = new ArrayList<>();
            allUsers.put(userName, usersList);
        } else // koga ima chatRoom vo sistemot
        {
            ArrayList<ChatRoom> usersList = new ArrayList<>(rooms.values());
            Collections.sort(usersList, new UsersComparator());

            String roomName = usersList.get(0).getName();

            rooms.get(roomName).addUser(userName); // dodava korisnik vo sobata
                                                    // so najmalku clenovi
            ArrayList<String> roomOfUser = new ArrayList<>();
            roomOfUser.add(roomName);
            allUsers.put(userName, roomOfUser); // dodava korisnik vo sistemot
                                                // koj e vo sobata so najmalku
                                                // clenovi
        }
    }

    public void registerAndJoin(String userName, String roomName) {
        ArrayList<String> roomsList = new ArrayList<>();
        roomsList.add(roomName);
        allUsers.put(userName, roomsList);// dodavame korisnik vo sistemot
        rooms.get(roomName).addUser(userName);// go dodavame korisnikot so
                                                // sobata so ima roomName
    }

    public void joinRoom(String userName, String roomName) throws NoSuchRoomException, NoSuchUserException {
        if (!rooms.containsKey(roomName)) {
            throw new NoSuchRoomException(roomName);
        }
        if (!allUsers.containsKey(userName)) {
            throw new NoSuchUserException(userName);
        }
        allUsers.get(userName).add(roomName);
        rooms.get(roomName).addUser(userName);
    }

    public void leaveRoom(String username, String roomName) throws NoSuchRoomException, NoSuchUserException {
        if (!rooms.containsKey(roomName))
            throw new NoSuchRoomException(roomName);
        if (allUsers.containsKey(username)) {
            if (allUsers.get(username).contains(roomName)) {
                rooms.get(roomName).removeUser(username);
                allUsers.get(username).remove(roomName);
            }
        } else{
            throw new NoSuchUserException(username);
        }
    }

    public void followFriend(String username, String friend_username) throws NoSuchUserException {
        if (!allUsers.containsKey(username))
            throw new NoSuchUserException(username);
        if (!rooms.isEmpty()) {
            if (!allUsers.get(friend_username).isEmpty()) {
                allUsers.get(username).clear();
                allUsers.get(username).addAll(allUsers.get(friend_username));
                ArrayList<String> roomsList = allUsers.get(username);
                for (int i = 0; i < roomsList.size(); i++) {
                    rooms.get(roomsList.get(i)).addUser(username);
                }
            }
        }
    }

    public void addRoom(String roomName) {
        rooms.put(roomName, new ChatRoom(roomName));
    }

    public void removeRoom(String roomName) {
        Set<String> set = allUsers.keySet();
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            allUsers.get(it.next()).remove(roomName);
        }
        rooms.remove(roomName);
    }

    public ChatRoom getRoom(String roomName) {
        return rooms.get(roomName);
    }
}
class UsersComparator implements Comparator<ChatRoom> {

    @Override
    public int compare(ChatRoom arg0, ChatRoom arg1) {
        return arg0.numUsers() - arg1.numUsers();
    }

}
@SuppressWarnings("serial")
 class NoSuchRoomException extends Exception {
    public NoSuchRoomException(String s){
        super(s);
    }
}@SuppressWarnings("serial")
 class NoSuchUserException extends Exception {
    public NoSuchUserException(String s){
        super(s);
    }
}