




from __future__ import annotations

from bisect import bisect_left
from functools import total_ordering
from heapq import merge




@total_ordering
class 						__lowercase		(UpperCamelCase__							):




      """simple docstring"""





      def __lt__(				self    ,				A     )		->    Optional[Any]:
         return self[-1] < other[-1]

      def __eq__(				self    ,				A     )		->    Union[str, Any]:
         return self[-1] == other[-1]




def 						SCREAMING_SNAKE_CASE__ (   lowercase					)  ->       list:
   snake_case				:    list[Stack]           =	[]
   # sort into stacks
   for element in collection:
      snake_case				:    str           =	Stack([element]					)
      snake_case				:    Optional[int]           =	bisect_left(lowercase						,lowercase					)
      if i != len(lowercase					):
         stacks[i].append(lowercase					)
      else:
         stacks.append(lowercase					)

    # use a heap-based merge to merge stack efficiently
   snake_case				:    Dict           =	merge(*(reversed(lowercase					) for stack in stacks)					)
   return collection


if __name__ == "__main__":
       lowerCamelCase	:	Any				=   input('Enter numbers separated by a comma:\n').strip()
       lowerCamelCase	:	List[Any]				=   [int(item) for item in user_input.split(',')]
       print(patience_sort(unsorted))











def 						SCREAMING_SNAKE_CASE__ (   )  ->       Dict:
   snake_case				:    Optional[int]           =	[]
   snake_case				:    Tuple           =	1

   while len(lowercase					) < 1E6:
      constant.append(str(lowercase					)					)
      i += 1

   snake_case				:    int           =	"""""".join(lowercase					)

   return (
       int(constant[0]					)
       * int(constant[9]					)
       * int(constant[99]					)
       * int(constant[999]					)
       * int(constant[9999]					)
       * int(constant[99999]					)
       * int(constant[999999]					)
   )


if __name__ == "__main__":
       print(solution())





