namespace HeroesSelection
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    public static class HeroesSelectionMain
    {
        private const string End = "Make a decision already!";
        private const string DarkSorcery = "does Gyubek!";

        private static readonly ICollection<string> NegativeTraits = new HashSet<string>
        {
            "Greedy",
            "Rude",
            "Dumb"
        };
        private static readonly IDictionary<string, int> SpecialFactorByTrait = new Dictionary<string, int>
        {
            { "Kind", 2 },
            { "Handsome", 3 },
            { "Smart", 5 }
        };
        private static readonly IDictionary<string, IDictionary<string, int>> TraitValueByTraitByPerson
            = new Dictionary<string, IDictionary<string, int>>();
        private static readonly IDictionary<string, int> TraitsSumByPerson
            = new Dictionary<string, int>();

        public static void Main()
        {
            string input = GetValidatedInput(Console.ReadLine);

            while (input != End)
            {
                string[] args = input.Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);

                string name = args[0];

                if (input.EndsWith(DarkSorcery))
                {
                    if (TraitValueByTraitByPerson.ContainsKey(name))
                    {
                        IDictionary<string, int> entries = new Dictionary<string, int>();

                        foreach (var entry in TraitValueByTraitByPerson[name])
                        {
                            if (NegativeTraits.Contains(entry.Key))
                            {
                                entries.Add(entry.Key, entry.Value);
                            }
                        }

                        TraitValueByTraitByPerson[name] = entries;
                        TraitsSumByPerson[name] = 0;
                    }

                    input = GetValidatedInput(Console.ReadLine);
                    continue;
                }

                string trait = args[1];
                int traitValue = int.Parse(args[2]);

                if (TraitValueByTraitByPerson.ContainsKey(name))
                {
                    if (TraitValueByTraitByPerson[name].ContainsKey(trait))
                    {
                        if (traitValue < TraitValueByTraitByPerson[name][trait])
                        {
                            int value = TraitValueByTraitByPerson[name][trait];

                            if (SpecialFactorByTrait.ContainsKey(trait))
                            {
                                value /= SpecialFactorByTrait[trait];
                            }

                            traitValue = value;
                        }
                    }
                }

                if (NegativeTraits.Contains(trait))
                {
                    traitValue = int.Parse(string.Format("-{0}", traitValue));
                }
                else if (SpecialFactorByTrait.ContainsKey(trait))
                {
                    traitValue *= SpecialFactorByTrait[trait];
                }

                if (TraitValueByTraitByPerson.ContainsKey(name))
                {
                    TraitValueByTraitByPerson[name][trait] = traitValue;
                    TraitsSumByPerson[name] += traitValue;
                }
                else
                {
                    TraitValueByTraitByPerson[name] = new Dictionary<string, int>
                    {
                        { trait, traitValue }
                    };
                    TraitsSumByPerson[name] = traitValue;
                }

                input = GetValidatedInput(Console.ReadLine);
            }

            var ordered = TraitsSumByPerson
                .OrderByDescending(e => e.Value)
                .ThenBy(e => e.Key);

            foreach (var entry in ordered)
            {
                var value = TraitValueByTraitByPerson[entry.Key];

                Console.WriteLine("# {0}: {1}", entry.Key, value.Sum(e => e.Value));

                foreach (var subentry in value.OrderByDescending(e => e.Value))
                {
                    Console.WriteLine("!!! {0} -> {1}", subentry.Key, subentry.Value);
                }
            }
        }

        private static string GetValidatedInput(Func<string> func)
        {
            string result = func.Invoke();

            if (string.IsNullOrEmpty(result) || string.IsNullOrWhiteSpace(result))
            {
                return null;
            }

            return result;
        }
    }
}