






from __future__ import annotations




def 					lowercase__				(					__snake_case   :							list[int]  ):


					'''simple docstring'''


					if len(__snake_case  ) == 0:
										return array

					UpperCAmelCase_	,  UpperCAmelCase_   :				List[Any]						=						min(__snake_case  ), max(__snake_case  )

					# Compute the variables
					UpperCAmelCase_   :				str						=						_max - _min + 1
					UpperCAmelCase_	,  UpperCAmelCase_   :				Dict						=						[0] * holes_range, [0] * holes_range

					# Make the sorting.
					for i in array:
										UpperCAmelCase_   :				Optional[Any]						=						i - _min
										UpperCAmelCase_   :				List[Any]						=						i
										holes_repeat[index] += 1

					# Makes the array back by replacing the numbers.
					UpperCAmelCase_   :				Optional[int]						=						0
					for i in range(__snake_case  ):
										while holes_repeat[i] > 0:
															UpperCAmelCase_   :				List[str]						=						holes[i]
															index += 1
															holes_repeat[i] -= 1

    # Returns the sorted array.
					return array


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		__UpperCAmelCase     							=						input('Enter numbers separated by comma:\n')
		__UpperCAmelCase     							=						[int(x) for x in user_input.split(',')]
		print(pigeon_sort(unsorted))














def 					lowercase__				(					__snake_case   :							str					,	__snake_case   :							int					,	__snake_case   :							List[str]  ):


					'''simple docstring'''


					if n == 0:
										return 1

					elif n % 2 == 1:
										return (binary_exponentiation(__snake_case					,	n - 1					,	__snake_case  ) * a) % mod

					else:
										UpperCAmelCase_   :				Optional[int]						=						binary_exponentiation(__snake_case					,	n / 2					,	__snake_case  )
										return (b * b) % mod


# a prime number
__UpperCAmelCase     							=						701

__UpperCAmelCase     							=						1000000000
__UpperCAmelCase     							=						10

# using binary exponentiation function, O(log(p)):
print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p)






print((a / b) % p == (a * b ** (p - 2)) % p)






