"""simple docstring"""
import sys

sys.set_int_max_str_digits(0)  # type: ignore







def 		__a  (      _SCREAMING_SNAKE_CASE  )      ->bool:
  a__:	Optional[Any]     				=      [0] * 11
  a__:	Tuple     				=      [0] * 11

  # mark last 9 numbers
  for _ in range(9  ):
    a__:	Union[str, Any]     				=      1
    a__:	List[Any]     				=      number // 10
  # flag
  a__:	Optional[Any]     				=      True

  # check last 9 numbers for pandigitality

  for x in range(9  ):
    if not check_last[x + 1]:
      a__:	List[Any]     				=      False
  if not f:
    return f

  # mark first 9 numbers
  a__:	Optional[int]     				=      int(str(_SCREAMING_SNAKE_CASE  )[:9]  )

  for _ in range(9  ):
    a__:	List[str]     				=      1
    a__:	List[Any]     				=      number // 10

  # check first 9 numbers for pandigitality

  for x in range(9  ):
    if not check_front[x + 1]:
      a__:	Dict     				=      False
  return f







def 		__a  (      _SCREAMING_SNAKE_CASE  )      ->bool:
  a__:	List[str]     				=      [0] * 11

  # mark last 9 numbers
  for _ in range(9  ):
    a__:	Union[str, Any]     				=      1
    a__:	List[Any]     				=      number // 10
  # flag
  a__:	str     				=      True

  # check last 9 numbers for pandigitality

  for x in range(9  ):
    if not check_last[x + 1]:
      a__:	Optional[Any]     				=      False
  return f







def 		__a  (      )      ->int:
  a__:	Optional[Any]     				=      1
  a__:	int     				=      1
  a__:	Any     				=      2
  # temporary Fibonacci numbers

  a__:	Union[str, Any]     				=      1
  a__:	Optional[Any]     				=      1
  a__:	Optional[Any]     				=      2
  # temporary Fibonacci numbers mod 1e9

  # mod m=1e9, done for fast optimisation
  a__:	Tuple     				=      [0] * 1000000
  a__:	List[Any]     				=      1000000000

  for x in range(1000000  ):
    a__:	Optional[Any]     				=      (aa + ba) % m
    a__:	Union[str, Any]     				=      ba % m
    a__:	int     				=      ca % m
    if checka(_SCREAMING_SNAKE_CASE  ):
      a__:	Optional[Any]     				=      1

  for x in range(1000000  ):
    a__:	List[str]     				=      a + b
    a__:	Union[str, Any]     				=      b
    a__:	Any     				=      c
    # perform check only if in tocheck
    if tocheck[x + 3] and check(_SCREAMING_SNAKE_CASE  ):
      return x + 3  # first 2 already done
  return -1


if __name__ == "__main__":
 print(f"{solution() = }")







def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if right <= left:
										return
					lowercase						   =       lowercase						   =       left
					lowercase						   =       right
					lowercase						   =       sorting[left]
					while i <= b:
										if sorting[i] < pivot:
															lowercase   ,      lowercase						   =       sorting[i], sorting[a]
															a += 1
															i += 1
										elif sorting[i] > pivot:
															lowercase   ,      lowercase						   =       sorting[i], sorting[b]
															b -= 1
										else:
															i += 1
					quick_sort_apartition(_UpperCAmelCase       ,			_UpperCAmelCase       ,			a - 1				)
					quick_sort_apartition(_UpperCAmelCase       ,			b + 1       ,			_UpperCAmelCase				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if left < right:
										lowercase						   =       lomuto_partition(_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				)
										quick_sort_lomuto_partition(_UpperCAmelCase       ,			_UpperCAmelCase       ,			pivot_index - 1				)
										quick_sort_lomuto_partition(_UpperCAmelCase       ,			pivot_index + 1       ,			_UpperCAmelCase				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					lowercase						   =       sorting[right]
					lowercase						   =       left
					for i in range(_UpperCAmelCase       ,			_UpperCAmelCase				):
										if sorting[i] < pivot:
															lowercase   ,      lowercase						   =       sorting[i], sorting[store_index]
															store_index += 1
					lowercase   ,      lowercase						   =       sorting[store_index], sorting[right]
					return store_index





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					if len(_UpperCAmelCase				) <= 1:
										return sorting
					return (
					    three_way_radix_quicksort([i for i in sorting if i < sorting[0]]				)
					    + [i for i in sorting if i == sorting[0]]
					    + three_way_radix_quicksort([i for i in sorting if i > sorting[0]]				)
					)


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)

		__magic_name__       =     input('''Enter numbers separated by a comma:\n''').strip()
		__magic_name__       =     [int(item) for item in user_input.split(''',''')]
		quick_sort_apartition(unsorted, 0, len(unsorted) - 1)
		print(unsorted)






