using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;

class Program
{
    static void Main()
    {
        var items = new SortedSet<Item>();
        var itemsByName = new Dictionary<string, Item>();
        var itemsByType = new Dictionary<string, SortedSet<Item>>();
        string input = "";
        StringBuilder result = new StringBuilder();

        while (input != "end")
        {
            input = Console.ReadLine();

            var inputElements = input.Split();
            var command = inputElements[0];

            switch (command)
            {
                case "add":
                    string name = inputElements[1];
                    double price = double.Parse(inputElements[2], CultureInfo.InvariantCulture);
                    string itemType = inputElements[3];
                    if (itemsByName.ContainsKey(name))
                    {
                        result.AppendLine($"Error: Item {name} already exists");
                    }
                    else
                    {
                        var item = new Item(name, price, itemType);
                        items.Add(item);
                        itemsByName[name] = item;

                        if (!itemsByType.ContainsKey(itemType))
                        {
                            itemsByType[itemType] = new SortedSet<Item>();
                        }
                        itemsByType[itemType].Add(item);

                        result.AppendLine($"Ok: Item {name} added successfully");
                    }
                    break;

                case "filter":
                    var filterType = inputElements[2];
                    if (filterType == "type")
                    {
                        FilterByType(inputElements[3], itemsByType, result);
                    }
                    else if (filterType == "price")
                    {
                        if (inputElements.Length == 7)
                        {
                            double minPrice = double.Parse(inputElements[4], CultureInfo.InvariantCulture);
                            double maxPrice = double.Parse(inputElements[6], CultureInfo.InvariantCulture);
                            FilterByPriceRange(minPrice, maxPrice, items, result);
                        }
                        else if (inputElements[3] == "from")
                        {
                            double minPrice = double.Parse(inputElements[4], CultureInfo.InvariantCulture);
                            FilterByPriceFrom(minPrice, items, result);
                        }
                        else if (inputElements[3] == "to")
                        {
                            double maxPrice = double.Parse(inputElements[4], CultureInfo.InvariantCulture);
                            FilterByPriceTo(maxPrice, items, result);
                        }
                    }
                    break;
            }
        }
        Console.WriteLine(result.ToString());
    }

    static void FilterByType(string itemType, Dictionary<string, SortedSet<Item>> itemsByType,StringBuilder result)
    {
        if (!itemsByType.ContainsKey(itemType))
        {
            result.AppendLine($"Error: Type {itemType} does not exist");
            return;
        }

        var filteredItems = itemsByType[itemType]
            .Take(10)
            .Select(item => $"{item.Name}({item.Price.ToString("F2", CultureInfo.InvariantCulture)})");

        PrintFilteredItems(filteredItems, result);
    }

    static void FilterByPriceRange(double minPrice, double maxPrice, SortedSet<Item> items,StringBuilder result)
    {
        var filteredItems = items
            .Where(item => item.Price >= minPrice && item.Price <= maxPrice)
            .Take(10)
            .Select(item => $"{item.Name}({item.Price.ToString("F2", CultureInfo.InvariantCulture)})");

        PrintFilteredItems(filteredItems, result);
    }

    static void FilterByPriceFrom(double minPrice, SortedSet<Item> items,StringBuilder result)
    {
        var filteredItems = items
            .Where(item => item.Price >= minPrice)
            .Take(10)
            .Select(item => $"{item.Name}({item.Price.ToString("F2", CultureInfo.InvariantCulture)})");

        PrintFilteredItems(filteredItems, result);
    }

    static void FilterByPriceTo(double maxPrice, SortedSet<Item> items,StringBuilder result)
    {
        var filteredItems = items
            .Where(item => item.Price <= maxPrice)
            .Take(10)
            .Select(item => $"{item.Name}({item.Price.ToString("F2", CultureInfo.InvariantCulture)})");

        PrintFilteredItems(filteredItems, result);
    }

    static void PrintFilteredItems(IEnumerable<string> filteredItems,StringBuilder result)
    {
        if (filteredItems.Any())
        {
            result.AppendLine($"Ok: {string.Join(", ", filteredItems)}");
        }
        else
        {
            result.AppendLine("Ok: ");
        }
    }

    class Item : IComparable<Item>
    {
        public string Name { get; }
        public double Price { get; }
        public string Type { get; }

        public Item(string name, double price, string type)
        {
            Name = name;
            Price = price;
            Type = type;
        }

        public int CompareTo(Item other)
        {
            int priceComparison = Price.CompareTo(other.Price);
            if (priceComparison != 0) return priceComparison;

            if (Name != other.Name) return string.Compare(Name, other.Name, StringComparison.Ordinal);

            return string.Compare(Type, other.Type, StringComparison.Ordinal);
        }

        public override bool Equals(object obj)
        {
            if (obj is Item other)
            {
                return Name == other.Name && Price == other.Price && Type == other.Type;
            }
            return false;
        }

        public override int GetHashCode()
        {
            return Tuple.Create(Name, Price, Type).GetHashCode();
        }
    }
}