




import random




def 					lowerCamelCase__       (						A__       :					Optional[Any]  ,			A__       :					Optional[int]  ,			A__       :					List[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						a[left_index]
       __lowerCamelCase   =						left_index + 1
       for j in range(left_index + 1  ,			__a	):
              if a[j] < pivot:
                     __lowerCamelCase   =						a[i], a[j]
                     i += 1
       __lowerCamelCase   =						a[i - 1], a[left_index]
       return i - 1




def 					lowerCamelCase__       (						A__       :					Any  ,			A__       :					Any  ,			A__       :					Any	):





       '''simple docstring'''



       if left < right:
              __lowerCamelCase   =						random.randint(__a  ,			right - 1	)
              __lowerCamelCase   =						(
                  a[left],
                  a[pivot],
              )  # switches the pivot with the left most bound
              __lowerCamelCase   =						partition(__a  ,			__a  ,			__a	)
              quick_sort_random(
                  __a  ,			__a  ,			__a	)  # recursive quicksort to the left of the pivot point
              quick_sort_random(
                  __a  ,			pivot_index + 1  ,			__a	)  # recursive quicksort to the right of the pivot point




def 					lowerCamelCase__       (						):





       '''simple docstring'''



       __lowerCamelCase   =						input("""Enter numbers separated by a comma:\n"""	).strip()
       __lowerCamelCase   =						[int(__a	) for item in user_input.split(""","""	)]

       quick_sort_random(__a  ,			0  ,			len(__a	)	)

       print(__a	)


if __name__ == "__main__":
       main()





'''simple docstring'''
__snake_case							      =     65521


def 			a      (			__a   )  ->	int:



					'''simple docstring'''






					UpperCamelCase__   :Tuple												= 1
					UpperCamelCase__   :Any												= 0
					for plain_chr in plain_text:
										UpperCamelCase__   :List[str]												= (a + ord(__a   )) % MOD_ADLER
										UpperCamelCase__   :Tuple												= (b + a) % MOD_ADLER
					return (b << 16) | a