
'''simple docstring'''







from __future__ import annotations

def 				_snake_case (		lowercase						)       ->       list[int]:
				if not list_of_ints:
								return []

				if min(lowercase						) < 0:
								raise ValueError("""All numbers must be positive"""						)

				__a       :     Optional[int]								=	max(len(bin(lowercase						)[2:]						) for x in list_of_ints						)
				return _msd_radix_sort(lowercase			,    lowercase						)

def 				_snake_case (		lowercase			,    lowercase						)       ->       list[int]:
				if bit_position == 0 or len(lowercase						) in [0, 1]:
								return list_of_ints

				__a       :     Tuple								=	[]
				__a       :     str								=	[]
				# Split numbers based on bit at bit_position from the right
				for number in list_of_ints:
								if (number >> (bit_position - 1)) & 1:
												# number has a one at bit bit_position
												ones.append(lowercase						)
								else:
												# number has a zero at bit bit_position
												zeros.append(lowercase						)

    # recursively split both lists further
				__a       :     Any								=	_msd_radix_sort(lowercase			,    bit_position - 1						)
				__a       :     Union[str, Any]								=	_msd_radix_sort(lowercase			,    bit_position - 1						)

				# recombine lists
				__a       :     List[str]								=	zeros
				res.extend(lowercase						)

				return res

def 				_snake_case (		lowercase						)       ->       int:
				__a       :     Optional[Any]								=	len(lowercase						)
				if not list_of_ints or length == 1:
								return

				if min(lowercase						) < 0:
								raise ValueError("""All numbers must be positive"""						)

				__a       :     Optional[int]								=	max(len(bin(lowercase						)[2:]						) for x in list_of_ints						)
				_msd_radix_sort_inplace(lowercase			,    lowercase			,    0			,    lowercase						)

def 				_snake_case (		lowercase			,    lowercase			,    lowercase			,    lowercase						)       ->       List[Any]:
				if bit_position == 0 or end_index - begin_index <= 1:
								return

				bit_position -= 1

				__a       :     int								=	begin_index
				__a       :     Optional[Any]								=	end_index - 1
				while i <= j:
								__a       :     Any								=	False
								if not (list_of_ints[i] >> bit_position) & 1:
												# found zero at the beginning
												i += 1
												__a       :     List[Any]								=	True
								if (list_of_ints[j] >> bit_position) & 1:
												# found one at the end
												j -= 1
												__a       :     Union[str, Any]								=	True

								if changed:
												continue

								__a							,	__a       :     Any								=	list_of_ints[j], list_of_ints[i]
								j -= 1
								if j != i:
												i += 1

				_msd_radix_sort_inplace(lowercase			,    lowercase			,    lowercase			,    lowercase						)
				_msd_radix_sort_inplace(lowercase			,    lowercase			,    lowercase			,    lowercase						)


if __name__ == "__main__":
					import doctest

					doctest.testmod()

'''simple docstring'''







def 				_snake_case (		lowercase = 2_0						)       ->       int:

				try:
								__a       :     Optional[Any]								=	int(lowercase						)
				except (TypeError, ValueError):
								raise TypeError("""Parameter n must be int or castable to int."""						)
				if n <= 0:
								raise ValueError("""Parameter n must be greater than or equal to one."""						)
				__a       :     List[Any]								=	0
				while 1:
								i += n * (n - 1)
								__a       :     Union[str, Any]								=	0
								for j in range(2			,    lowercase						):
												if i % j != 0:
																__a       :     Any								=	1
																break
								if nfound == 0:
												if i == 0:
																__a       :     List[str]								=	1
												return i
				return None


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