


def 				__lowerCamelCase						( UpperCAmelCase_						:		str						):




      """simple docstring"""





      assert column_title.isupper()
      a						:Tuple 							=       0
      a						:Any 							=       len(UpperCAmelCase_						) - 1
      a						:Tuple 							=       0

      while index >= 0:
            a						:str 							=       (ord(column_title[index]						) - 64) * pow(26 ,  UpperCAmelCase_						)
            answer += value
            power += 1
            index -= 1

      return answer


if __name__ == "__main__":
     from doctest import testmod

     testmod()







"""simple docstring"""




from __future__ import annotations

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

@total_ordering
class 		a__						(      a_						):
   def __lt__(			self	,    _a				):
          return self[-1] < other[-1]

   def __eq__(			self	,    _a				):
          return self[-1] == other[-1]


def   __magic_name__	(      __snake_case				:       list  ) ->				list:
       lowercase    :				list[Stack]       		=							[]
       # sort into stacks
       for element in collection:
              lowercase    :				Union[str, Any]       		=							Stack([element]  )
              lowercase    :				Dict       		=							bisect_left(__snake_case     , __snake_case  )
              if i != len(__snake_case  ):
                     stacks[i].append(__snake_case  )
              else:
                     stacks.append(__snake_case  )

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


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


