import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
       // BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        InventoryManager manager = new InventoryManager();
        //String input = br.readLine();
        String input = scanner.nextLine();
        StringBuilder filter = new StringBuilder();
        List<Product> filtered;


        while (!input.equals("end")) {
            String command = input.split(" ")[0];


            if (command.equals("add")) {
                String[] parameters = input.split(" ");
                Product product = new Product(parameters[1], Double.parseDouble(parameters[2]), parameters[3]);
                manager.add(product);


            } else if (input.contains("filter by type")) {


                String type = input.split(" ")[3];
                filtered = manager.filterByType(manager.items, type);


                boolean hasType = manager.items.values()
                        .stream()
                        .anyMatch(product -> product.type.equals(type));


                if (hasType) {
                    filtered = manager.sortList(filtered);
                    filter.append("Ok: ");


                    for (Product product : filtered) {
                        filter.append(product.name).append("(").append(product.price).append("), ");
                    }


                    System.out.println(filter.toString().substring(0, filter.length() - 2));
                    filter = new StringBuilder();


                } else {
                    System.out.printf("Error: Type %s does not exists%n", type);
                }


                filter = new StringBuilder();


            } else if (input.contains("filter by price")) {
                String[] parameters = input.split(" ");


                if (parameters.length == 5) {
                    double filterPrice = Double.parseDouble(parameters[4]);


                    if (parameters[3].equals("from")) {
                        filtered = manager.filterByPriceFrom(manager.items, filterPrice);


                        if (filtered.isEmpty()) {
                            System.out.println("Ok: ");
                        } else {
                            filtered = manager.sortList(filtered);
                            filter.append("Ok: ");
                            for (Product product : filtered) {
                                filter.append(product.name).append("(").append(product.price).append("), ");
                            }
                            System.out.println(filter.toString().substring(0, filter.length() - 2));
                            filter = new StringBuilder();
                        }


                    } else {
                        filtered = manager.filterByPriceTo(manager.items, filterPrice);


                        if (filtered.isEmpty()) {
                            System.out.println("Ok: ");


                        } else {
                            filtered = manager.sortList(filtered);
                            filter.append("Ok: ");
                            for (Product product : filtered) {
                                filter.append(product.name).append("(").append(product.price).append("), ");
                            }


                            System.out.println(filter.toString().substring(0, filter.length() - 2));
                            filter = new StringBuilder();
                        }
                    }


                } else {
                    double filterPriceFrom = Double.parseDouble(parameters[4]);
                    double filterPriceTo = Double.parseDouble(parameters[6]);
                    filtered = manager.filterByPriceFromTo(manager.items, filterPriceFrom, filterPriceTo);


                    if (filtered.isEmpty()) {
                        System.out.println("Ok: ");


                    } else {
                        filtered = manager.sortList(filtered);
                        filter.append("Ok: ");


                        for (Product product : filtered) {
                            filter.append(product.name).append("(").append(product.price).append("), ");
                        }


                        System.out.println(filter.toString().substring(0, filter.length() - 2));
                        filter = new StringBuilder();
                    }
                }
            }
            //input = br.readLine();
            input = scanner.nextLine();
        }
    }

    public static class Product implements Comparable<Product> {


        private final String name;
        private final double price;
        private final String type;


        public Product(String name, double price, String type) {
            this.name = name;
            this.price = price;
            this.type = type;
        }


        @Override
        public int compareTo(Product product) {
            int result = 0;
            if (this.price > product.price) result = 1;
            if (this.price < product.price) result = -1;
            if (this.price == product.price) {
                result = this.name.compareTo(product.name);
            }
            return result;
        }
    }

    public static class InventoryManager {
        private final Map<String, Product> items;

        public InventoryManager() {
            items = new HashMap<>();
        }

        public void add(Product product) {
            if (items.containsKey(product.name)) {
                System.out.printf("Error: Item %s already exists%n", product.name);
            } else {
                items.put(product.name, product);
                System.out.printf("Ok: Item %s added successfully%n", product.name);
            }
        }

        public List<Product> filterByType(Map<String, Product> mapToFilter, String type) {
            return mapToFilter.values().stream().filter(product -> product.type.equals(type))
                    .collect(Collectors.toList());
        }

        public List<Product> filterByPriceFrom(Map<String, Product> mapToFilter, Double priceToCompare) {
            return mapToFilter.values().stream().filter(product -> product.price >= priceToCompare)
                    .collect(Collectors.toList());
        }

        public List<Product> filterByPriceTo(Map<String, Product> mapToFilter, Double priceToCompare) {
            return mapToFilter.values().stream().filter(product -> product.price <= priceToCompare)
                    .collect(Collectors.toList());
        }

        public List<Product> sortList(List<Product> list) {
            return list
                    .stream()
                    .sorted()
                    .limit(10)
                    .collect(Collectors.toList());
        }

        public List<Product> filterByPriceFromTo(Map<String, Product> mapToFilter, Double priceFrom, Double priceTo) {
            return mapToFilter.values()
                    .stream()
                    .filter(product -> product.price >= priceFrom && product.price <= priceTo)
                    .collect(Collectors.toList());
        }
    }
}