using System;
using System.Linq;

namespace P05.LongestIncreasingSubsequence
{
    class LongestIncreasingSubsequence
    {
        static void Main(string[] args)
        {
            int[] numbers = Console.ReadLine()
                .Split(' ', StringSplitOptions.RemoveEmptyEntries)
                .Select(int.Parse)
                .ToArray();

            if (numbers.Length == 1)
            {
                Console.WriteLine(string.Join(' ', numbers));
                return;
            }

            int[] numbersCopy = numbers;
            string currentOutput = numbersCopy[0] + " ";
            int maxNumber = numbersCopy[0];
            int maxLength = -1;
            int[] LIS = new int[0];
            int savedIndex = 0;

            for (int currentIndex = 0; currentIndex < numbersCopy.Length; currentIndex++)
            {
                if (numbersCopy[currentIndex] > maxNumber)
                {
                    currentOutput += numbersCopy[currentIndex] + " ";
                    maxNumber = numbersCopy[currentIndex];

                    int[] currentOutputToArr = currentOutput
                        .Split(' ', StringSplitOptions.RemoveEmptyEntries)
                        .Select(int.Parse)
                        .ToArray();

                    if (currentOutputToArr.Length > maxLength)
                    {
                        maxLength = currentOutputToArr.Length;
                        LIS = currentOutputToArr;
                    }
                }

                if (currentIndex == numbersCopy.Length - 1)
                {
                    int indexCounter = 0;
                    bool isFoundRedundantIndex = false;

                    if (maxNumber == numbersCopy[savedIndex])
                    {
                        int[] newNumbers = new int[numbers.Length - 1];

                        for (int currIndex = 0; currIndex < newNumbers.Length; currIndex++)
                        {
                            if (numbers[indexCounter] != maxNumber || isFoundRedundantIndex)
                            {
                                newNumbers[currIndex] = numbers[indexCounter];
                            }
                            else
                            {
                                currIndex--;
                                isFoundRedundantIndex = true;
                            }

                            indexCounter++;
                        }

                        numbers = newNumbers;

                        if (numbers.Length == 0)
                        {
                            break;
                        }
                        numbersCopy = newNumbers;

                        currentIndex = -1;
                        currentOutput = numbersCopy[0] + " ";
                        maxNumber = numbersCopy[0];
                        continue;
                    }

                    int[] previousNumbers = new int[numbersCopy.Length - 1];

                    for (int currIndex = 0; currIndex < previousNumbers.Length; currIndex++)
                    {
                        if (numbersCopy[indexCounter] != maxNumber || isFoundRedundantIndex)
                        {
                            previousNumbers[currIndex] = numbersCopy[indexCounter];
                        }
                        else
                        {
                            currIndex--;
                            isFoundRedundantIndex = true;
                        }

                        indexCounter++;
                    }

                    numbersCopy = previousNumbers;
                    currentIndex = -1;
                    maxNumber = numbersCopy[0];
                    currentOutput = numbersCopy[0] + " ";
                }
            }

            Console.Write(string.Join(' ', LIS));
        }
    }
}