Imenik_stream

import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class PhoneBookTest {

	public static void main(String[] args) {
		PhoneBook phoneBook = new PhoneBook();
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		scanner.nextLine();
		for (int i = 0; i < n; ++i) {
			String line = scanner.nextLine();
			String[] parts = line.split(":");
			try {
				phoneBook.addContact(parts[0], parts[1]);
			} catch (DuplicateNumberException e) {
				System.out.println(e.getMessage());
			}
		}
		while (scanner.hasNextLine()) {
			String line = scanner.nextLine();
            System.out.println(line);
			String[] parts = line.split(":");
			if (parts[0].equals("NUM")) {
				phoneBook.contactsByNumber(parts[1]);
			} else {
				phoneBook.contactsByName(parts[1]);
			}
		}
	}

}

//
class DuplicateNumberException extends Exception
{
	DuplicateNumberException(String number)
	{
		super(String.format("Duplicate number: %s", number));
	}
}
class PhoneBook
{
	TreeSet<Contact> contacts;
	TreeMap<String, TreeSet<Contact>> name_contacts;
	public PhoneBook() {
		// TODO Auto-generated constructor stub
		contacts = new TreeSet<>();
		name_contacts = new TreeMap<>();
		}

	void addContact(String name, String number) throws DuplicateNumberException
	{

		Contact contact = new Contact(name, number);
		if(contacts.contains(contact))
			throw new DuplicateNumberException(number);
		else
			contacts.add(contact);

		if(!name_contacts.containsKey(name))
		{
			TreeSet<Contact> temp = new TreeSet<>();
			temp.add(contact)
			;
			name_contacts.put(name, temp);
		}
		else
		{
			TreeSet<Contact> temp = name_contacts.get(name);
			temp.add(contact);
			name_contacts.put(name, temp);
		}

		/*
		contacts.computeIfAbsent
		(number, val -> {
			TreeSet<Contact> conT = new TreeSet<Contact>(Comparator.comparing(Contact::getName).thenComparing(Contact::getNumber));;
			conT.add(new Contact(name, number));
			return conT;
		});
		contacts.computeIfPresent(number, (key ,value) -> {
			value.add(new Contact(name, number));
			return value;
		});
		name_contacts.compute
		(name, (key, val) -> {
			if(val==null)
				{
					val = new TreeSet<>(Comparator.comparing(Contact::getName)
									.thenComparing(Contact::getNumber));
					val.add(new Contact(name, number));
				}
			else
				val.add(new Contact(name, number));
			return val;
		});*/


	}

	void contactsByNumber(String number)
	{
		if(!contacts.stream().anyMatch(x -> x.number.contains(number)))
			{
				System.out.println("NOT FOUND");
				return;
			}
		contacts.stream()
		.filter(x -> x.number.contains(number))
		//.sorted(Comparator.comparing(Contact::getName)
		//		.thenComparing(Contact::getNumber))
		.forEach(System.out::println);
	}
	void contactsByName(String name)
	{
		if(!name_contacts.containsKey(name))
		{
			System.out.println("NOT FOUND");
			return;
		}
		name_contacts.get(name).stream()
		.forEach(System.out::println);
	}
}

class Contact implements Comparable<Contact>
{
	String name, number;

	public Contact(String name, String number) {
		super();
		this.name = name;
		this.number = number;
	}

	public String getName() {
		return name;
	}

	public String getNumber() {
		return number;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return String.format("%s %s", name, number);
	}

	@Override
	public int compareTo(Contact arg0) {
		// TODO Auto-generated method stub
		if(name.compareTo(arg0.name)==0)
			return number.compareTo(arg0.number);
		return name.compareTo(arg0.name);
	}
}