

from __future__ import annotations

def  lowerCamelCase__ (					_a):
	if len(_a) == 0:
		return array

	SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE   :      List[Any]				     =       min(_a), max(_a)

	# Compute the variables
	SCREAMING_SNAKE_CASE   :      List[Any]				     =       _max - _min + 1
	SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE   :      List[str]				     =       [0] * holes_range, [0] * holes_range

	# Make the sorting.
	for i in array:
		SCREAMING_SNAKE_CASE   :      Dict				     =       i - _min
		SCREAMING_SNAKE_CASE   :      Tuple				     =       i
		holes_repeat[index] += 1

	# Makes the array back by replacing the numbers.
	SCREAMING_SNAKE_CASE   :      int				     =       0
	for i in range(_a):
		while holes_repeat[i] > 0:
			SCREAMING_SNAKE_CASE   :      Dict				     =       holes[i]
			index += 1
			holes_repeat[i] -= 1

    # Returns the sorted array.
	return array


if __name__ == "__main__":
			import doctest

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


from __future__ import annotations

def  lowerCamelCase__ (					_a							,			_a):
	if b == 0:
		return (1, 0)
	((SCREAMING_SNAKE_CASE)     ,(SCREAMING_SNAKE_CASE))   :      Tuple				     =       extended_euclid(_a							,			a % b)
	SCREAMING_SNAKE_CASE   :      Dict				     =       a // b
	return (y, x - k * y)

def  lowerCamelCase__ (					_a							,			_a							,			_a							,			_a):
	((SCREAMING_SNAKE_CASE)     ,(SCREAMING_SNAKE_CASE))   :      str				     =       extended_euclid(_a							,			_a)
	SCREAMING_SNAKE_CASE   :      str				     =       na * na
	SCREAMING_SNAKE_CASE   :      int				     =       ra * x * na + ra * y * na
	return (n % m + m) % m

def  lowerCamelCase__ (					_a							,			_a):
	((SCREAMING_SNAKE_CASE)     ,(SCREAMING_SNAKE_CASE))   :      List[str]				     =       extended_euclid(_a							,			_a)
	if b < 0:
		SCREAMING_SNAKE_CASE   :      int				     =       (b % n + n) % n
	return b

def  lowerCamelCase__ (					_a							,			_a							,			_a							,			_a):
	SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE   :      Dict				     =       invert_modulo(_a							,			_a), invert_modulo(_a							,			_a)
	SCREAMING_SNAKE_CASE   :      Optional[int]				     =       na * na
	SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       ra * x * na + ra * y * na
	return (n % m + m) % m


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

			testmod(name='chinese_remainder_theorem', verbose=True)
			testmod(name='chinese_remainder_theorem2', verbose=True)
			testmod(name='invert_modulo', verbose=True)
			testmod(name='extended_euclid', verbose=True)