using System;
using System.Linq;
using System.Collections.Generic;

namespace IloNanpa.Soko
{
    public class Soko
    {
        const byte Ala = 0;
        const byte Wan = 1;
        const byte Tu = Wan + Wan;
        const byte Luka = Tu + Tu + Wan;
        const byte Mute = Luka + Luka + Luka + Luka;
        const byte Ale = Mute + Mute + Mute + Mute + Mute;

        /**
         * soko kasi li ko pakala e ma la, ilo ni li soko e nanpa tawa toki pona
         */
        public static void Main(string[] pana)
        {
            Console.WriteLine("o pana e nanpa:");
            ulong nanpa;
            string linja = Console.ReadLine();
            // toki tawa jan kepeken
            Console.WriteLine("kili ona li ni:");
            if (ulong.TryParse(linja, out nanpa))
            {
                List<byte> kulupu = OSokoENanpaKepekenNasinNanpaPona(nanpa);
                Console.Write(string.Join(" ", kulupu.Select(n => Nanpa.NanpaTawaSitelen(n))));
                if (kulupu.SequenceEqual(new byte[] {5, 2, 1})) // o kute a e kalama pi jan Usawi
                    Console.Write(" 💃");
                Console.WriteLine();
            }
            else
            {
                Console.WriteLine(OKasiTawaNanpaTanSitelen(linja));
            }
        }

        /// <lili>
        ///   o ante e nanpa tawa sitelen kepeken nasin pu pona
        /// </lili>
        /// <poka>
        ///   ni li toki pona sama pu.
        ///
        ///   pana ona li sitelen ala li nanpa tawa sitelen.
        /// </poka>
        /// <pana nimi="nanpa">ni li nanpa li wan anu tu anu mute anu ala</pana>
        /// <kili>kulupu nanpa li nanpa e ijo la kulupu li jo e nanpa</kili>
        static List<byte> OSokoPuENanpa(ulong nanpa)
        {
            List<byte> kulupu = new List<byte>();
            // tenpo open la mi kama lili e nanpa lon tenpo sike
            // mi kepeken nanpa sitelen ale
            // te "wile nanpa en wan li ale" to li sama toki pona a a a
            while (nanpa + 1 > Ale)
            {
                nanpa -= Ale;
                kulupu.Add(Ale);
            }
            while (nanpa + 1 > Mute)
            {
                nanpa -= Mute;
                kulupu.Add(Mute);
            }
            while (nanpa + 1 > Luka)
            {
                nanpa -= Luka;
                kulupu.Add(Luka);
            }
            while (nanpa + 1 > Tu)
            {
                nanpa -= Tu;
                kulupu.Add(Tu);
            }
            while (nanpa + 1 > Wan)
            {
                nanpa -= Wan;
                kulupu.Add(Wan);
            }
            // tenpo pini la mi lukin e ni: nanpa li lon ala lon
            if (Ala >= kulupu.Count)
            {
                return new List<byte> { Ala };
            }
            return kulupu;
        }

        /// <lili>
        ///   o ante e nanpa tawa sitelen kepeken nasin pi nasin nanpa pona
        /// </lili>
        /// <poka>
        ///   nasin ni li kepeken nimi ale la nanpa open li mute ale e nanpa pini.
        ///
        ///   pana ona li sitelen ala li nanpa tawa sitelen.
        /// </poka>
        /// <pana nimi="nanpa">ni li nanpa li wan anu tu anu mute anu ala</pana>
        /// <kili>kulupu nanpa li nanpa e ijo la kulupu ni li jo e nanpa</kili>
        static List<byte> OSokoENanpaKepekenNasinNanpaPona(ulong nanpa)
        {
            // ni la nanpa li mute: nanpa pi nimi ale li lili, nanpa ni li suli
            ulong nanpaMute = nanpa / Ale;
            if (nanpaMute > Ala)
            {
                List<byte> tuLili;
                byte nanpaLili = (byte)(nanpa % Ale);
                // nimi "kipisi" anu nimi "%" li pona ala tawa mi
                // taso, nimi "tu" li pana e sona pi nasin nanpa, sona li tu ante a!
                if (Ala >= nanpaLili)
                    tuLili = new List<byte>();
                else
                    tuLili = OSokoPuENanpa(nanpaLili);
                List<byte> tuSuli = OSokoENanpaKepekenNasinNanpaPona(nanpaMute);
                tuSuli.Add(Ale);
                tuSuli.AddRange(tuLili);
                return tuSuli;
            }
            return OSokoPuENanpa(nanpa);
        }

        /// <lili>
        ///   o ante e sitelen tawa nanpa kepeken nasin nanpa pona
        /// </lili>
        /// <poka>
        ///   kasi li kama sitelen lipu li kepeken ma la, kasi li nasin soko ala
        /// </poka>
        /// <pana nimi="ona">ni li sitelen. kon li insa li sama sona tan sitelen la sitelen ni li kon sama nanpa lon</pana>
        /// <kili>nanpa li tan sitelen ona</kili>
        static ulong OKasiTawaNanpaTanSitelen(string ona)
        {
            ulong aleWan = Ala;
            byte nanpaTan = Ale;
            foreach (string sitelen in ona.Trim().Split((char[])null))
            {
                if (string.IsNullOrEmpty(sitelen)) continue;
                string sitelenPona = sitelen.ToLower();
                if (sitelenPona.Any(sitelenLili => sitelenLili is not ((>= 'a') and (<= 'z')))) continue;
                byte nanpa = Nanpa.SitelenTawaNanpa(sitelenPona);
                if (nanpa == Ale && nanpaTan < Ale)
                {
                    aleWan *= Ale;
                }
                else
                {
                    aleWan += nanpa;
                    nanpaTan = nanpa;
                }
            }
            return aleWan;
        }

        /**
         * ilo ni li ante e nanpa e sitelen
         */
        class Nanpa
        {
            internal static string NanpaTawaSitelen(byte nanpa) => nanpa switch
                {
                    Ala => "ala",
                    Wan => "wan",
                    Tu => "tu",
                    Luka => "luka",
                    Mute => "mute",
                    Ale => "ale",
                    _ => throw new ArgumentOutOfRangeException("nanpa", nanpa, $"nanpa {nanpa} li ken ala sitelen la, mi li alasa ala e ni"),
                };

            internal static byte SitelenTawaNanpa(string sitelen) => sitelen switch
                {
                    "ala" => Ala,
                    "wan" => Wan,
                    "tu" => Tu,
                    "luka" => Luka,
                    "mute" => Mute,
                    "ale" => Ale,
                    "ali" => Ale, // toki ante
                    _ => throw new ArgumentOutOfRangeException("sitelen", sitelen, $"mi alasa ala e sitelen nanpa ala ni: {sitelen}"),
                };
        }
    }
}