using System;
using CodEx;
namespace JedenProtiStu
{
    class Jeden_proti_stu
    {
        static Pole zasobnik;
        static void Main(string[] args)
        {
            int souperu = 100;
            int kol = Reader.Console().Int();
            int penez = 100000;
            int suma = 0;
            zasobnik = new Pole(souperu, kol);
           // zasobnik.Vypis();
          //  for (int i = 1; i <= 10; i++)
           // { 
            cifra(souperu, penez, suma, kol);
            Console.WriteLine(sup);
            foreach (int cislo in buffer2)
            {
                Console.Write("{0} ", cislo);
            }
          
            
           // }
          //  Console.WriteLine("--konec--");
           // Console.ReadLine(); //BACHA! MUSI SE PAK ZRUSIT
        }
        public static int sup = 0;
        
       class Pole 
        {
            int vyska;
            int sirka;
            public int[,] zasobnik;
            public void Vypis()
            {
                for (int i = 0; i <= vyska - 1; i++)
                    for (int j = 0; j <= sirka - 1; j++)
                    {
                        if(j<sirka-1){
                    Console.Write(" {0}  " ,  zasobnik[i, j]);}
                        else{
                            Console.WriteLine(" {0}  " ,  zasobnik[i, j]);
                        }
                    }
 
            }
            public Pole(int souperu, int kol)
            {
                this.zasobnik = new int[souperu, kol];
                this.vyska = souperu;
                this.sirka = kol;
                for(int i=0;i<=souperu-1;i++)
                    for (int j = 0; j <= kol-1; j++)
                    {
                        zasobnik[i, j] = 1;
                    }
            }
        }
       public static System.Collections.ArrayList buffer = new System.Collections.ArrayList();
       public static System.Collections.ArrayList buffer2 = new System.Collections.ArrayList();
        public static void cifra(int souperu, int penez, int suma,int kol)
        {
            if (kol > 0)
            {
                if (souperu > 0)
                {
                    for (int zbylo = 0; zbylo <= souperu; zbylo++)
                    {
                        suma = suma + penez * (souperu - zbylo) / souperu;
                        //kontrola
                       //if(zasobnik[souperu-1,kol-1]                       
                        Jeden_proti_stu.buffer.Add(souperu - zbylo);
                        cifra(zbylo, penez, suma, kol - 1);
                        suma = suma - penez * (souperu - zbylo) / souperu;
                        
                        //ODEBRAT POSLEDNI PRVEK 
                        Jeden_proti_stu.buffer.RemoveAt(Jeden_proti_stu.buffer.Count-1);
                    }
                }
                else 
                {

                }
            }
            else
            { //budovat string s cisly..}
                if (suma > Jeden_proti_stu.sup)
                {
                    Jeden_proti_stu.buffer2.Clear();
                    foreach (int cislo in buffer)
                    {
                        Jeden_proti_stu.buffer2.Add(cislo);
                    }
                    Jeden_proti_stu.sup = suma;
                    /*int[] temp = new int[buffer.Count];
   
                    foreach (string prvecek in buffer)
                    {
                        temp[j] = prvecek;
                        j++;
                    }


                    temp = buffer;

                    buffer.Clear();
                    jeden_proti_stu.vysledek = temp;*/
                }
            }
   
        }
    }
}
namespace CodEx
{

    /// <summary>
    /// Class Reader provides user friendly adaptor for reading text files and text console input.
    /// If offers simple methods to read numbers, chars and string tokens.
    /// </summary>
    public class Reader : System.IDisposable
    {

        #region Inicialization and destruction

        /// <summary>Initializes reader object and assigns given stream reader.</summary>
        /// <param name="s">Stream reader object used as input.</param>
        private Reader(System.IO.TextReader s)
        {
            stream = s;
            buf = new char[BUFLEN];
            index = 0;
            len = 0;
        }


        /// <summary>Opens given file and assigns it to created Reader object.</summary>
        /// <param name="fname">Name of the file to be opened.</param>
        public Reader(string fname) : this(new System.IO.StreamReader(fname, System.Text.Encoding.ASCII, false)) { }


        /// <summary>Static singleton value that keeps console Reader object.</summary>
        private static Reader console = null;

        /// <summary>Method providing access to universal console Reader object.</summary>
        public static Reader Console()
        {
            if (console == null)
                console = new Reader(System.Console.In);
            return console;
        }


        /// <summary>Internal disposer of reader stream.</summary>
        private void FreeStream()
        {
            if (stream != null)
            {
                ((System.IDisposable)stream).Dispose();
                stream = null;
            }
        }


        /// <summary>
        /// Method that closes the reader and underlying stream object.
        /// It is recomended to use this method rather than wait for fializer.
        /// </summary>
        public void Dispose()
        {
            FreeStream();
            System.GC.SuppressFinalize(this);
        }


        /// <summary>Finalizer is not usually used. But if it is, it does the same as Dispose method.</summary>
        ~Reader()
        {
            FreeStream();
        }

        #endregion


        #region Public core methods

        /// <summary>Reads one character from input.</summary>
        /// <param name="c">Output variable where the character is stored.</param>
        /// <returns>True if the reading was successfull, false otherwise.</returns>
        public bool Char(out char c)
        {
            if (!Update())
            {
                c = '\0';
                return false;
            }
            c = buf[index++];
            return true;
        }


        /// <summary>Reads integer number from text file.</summary>
        /// <param name="i">Output variable where the integer is stored.</param>
        /// <returns>True if the reading was successfull, false otherwise.</returns>
        public bool Int(out int i)
        {
            if (!SkipSpaces())
            {
                i = 0;
                return false;
            }
            i = 0;

            int sign = 1;
            if (buf[index] == '+')
                index++;
            else if (buf[index] == '-')
            {
                sign = -1;
                index++;
            }

            if (!Update() || !System.Char.IsDigit(buf[index]))
                throw new System.IO.IOException("No digit found when reading number.");

            while (Update() && System.Char.IsDigit(buf[index]))
            {
                i = i * 10 + sign * ((int)buf[index++] - (int)'0');
            }
            return true;
        }


        /// <summary>Reads real number from text file.</summary>
        /// <param name="d">Output variable where the double is stored.</param>
        /// <returns>True if the reading was successfull, false otherwise.</returns>
        public bool Double(out double d)
        {
            {
                int i;
                if (!Int(out i))
                {
                    d = 0;
                    return false;
                }
                d = i;
            }

            if (Update() && buf[index] == '.')
            {
                index++;
                double frac = 1.0;
                while (Update() && System.Char.IsDigit(buf[index]))
                {
                    frac /= 10.0;
                    d += frac * ((int)buf[index++] - (int)'0');
                }
            }
            if (Update() && System.Char.ToLower(buf[index]) == 'e')
            {
                index++;
                d *= System.Math.Pow(10, Int());	// If no exponent can be parsed -> IOException.
            }
            return true;
        }


        /// <summary>Reads one string token from input. Token does not contain any blank spaces.</summary>
        /// <returns>String object containing the token or null if reading was not successfull.</returns>
        public string Word()
        {
            if (!SkipSpaces())
                return null;
            int start = index;
            while (index < len && !System.Char.IsWhiteSpace(buf[index]))
                index++;
            if (index < len) return new string(buf, start, index - start);
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            sb.Append(buf, start, index - start);
            while (index == len && Update())
            {
                while (index < len && !System.Char.IsWhiteSpace(buf[index]))
                    index++;
                sb.Append(buf, 0, index);
            }
            return sb.ToString();
        }


        /// <summary>Reads rest of the line from input.</summary>
        /// <returns>String object containing the line or null if EOF was met.</returns>
        public string Line()
        {
            if (!Update())
                return null;
            int start = index;
            while (index < len && buf[index] != '\n')
                index++;
            if (index < len) return new string(buf, start, index++ - start);
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            sb.Append(buf, start, index - start);
            while (index == len && Update())
            {
                while (index < len && buf[index] != '\n')
                    index++;
                sb.Append(buf, 0, index);
            }
            if (index < len) index++;
            return sb.ToString();
        }

        #endregion


        #region Convenience methods

        /// <summary>Checks if the input stream ended.</summary>
        /// <returns>True if there are no more characters on the input.</returns>
        public bool EOF()
        {
            return !Update();
        }


        /// <summary>Skips whitespace characters and then checks for EOF.</summary>
        /// <returns>True if there are only blank characters left in the input.</returns>
        public bool SeekEOF()
        {
            return !SkipSpaces();
        }


        /// <summary>Alias for Dispose method that closes underlying stream.</summary>
        public void Close()
        {
            Dispose();
        }


        /// <summary>Reads one character from input. Throws IOException on error.</summary>
        /// <returns>Character that was read from the input.</returns>
        public char Char()
        {
            char ret;
            if (!Char(out ret))
                throw new System.IO.IOException("Reading after EOF.");
            return ret;
        }


        /// <summary>Reads integer number from input. Throws IOException on error.</summary>
        /// <returns>Integer that was read from the input.</returns>
        public int Int()
        {
            int ret;
            if (!Int(out ret))
                throw new System.IO.IOException("Reading after EOF.");
            return ret;
        }


        /// <summary>Reads real number from input. Throws IOException on error.</summary>
        /// <returns>Double that was read from the input.</returns>
        public double Double()
        {
            double ret;
            if (!Double(out ret))
                throw new System.IO.IOException("Reading after EOF.");
            return ret;
        }

        #endregion


        #region Fields

        /// <summary>Underlying stram object. It is not null while the stream is opened.</summary>
        private System.IO.TextReader stream;

        /// <summary>Read but unprocessed data. Null after EOF.</summary>
        private char[] buf;
        private const int BUFLEN = 16384;

        /// <summary>Actual index to the buf.</summary>
        private int index;

        /// <summary>Length of buf. Len == -1 means EOF.</summary>
        private int len;

        #endregion


        #region Private methods

        /// <summary>Ensures that index is lesser than len whenever possible.</summary>
        /// <returns>False on EOF, true otherwise.</returns>
        private bool Update()
        {			// 
            if (stream == null || len == -1)
                return false;
            if (index < len)
                return true;

            index = 0;
            if ((len = stream.Read(buf, 0, BUFLEN)) == 0)
            {
                len = -1;
                buf = null;
                return false;
            }
            return true;
        }


        /// <summary>Skip whitespaces.</summary>
        /// <returns>Returns false when EOF is found while skipping, true otherwise.</returns>
        private bool SkipSpaces()
        {
            while (Update())
            {
                while (index < len && System.Char.IsWhiteSpace(buf[index]))
                    index++;
                if (index < len)
                    return true;
            }
            return false;
        }

        #endregion
    }

}