from math import sqrt


def SCREAMING_SNAKE_CASE					(  lowercase_:						int					):
       _UpperCamelCase  :							Optional[Any]	    =	[1]
       for i in range(2		,    int(sqrt(lowercase_					)					) + 1		,    1					):
              if number % i == 0:
                     values.append(lowercase_					)
                     if int(number // i					) != i:
                            values.append(int(number // i					)					)
       return sorted(lowercase_					)


def SCREAMING_SNAKE_CASE					(  lowercase_:						int					):
       return sum(factors(lowercase_					)					) > n


def SCREAMING_SNAKE_CASE					(  lowercase_:						int					):
       _UpperCamelCase  :							Optional[Any]	    =	factors(lowercase_					)
       _UpperCamelCase  :							Optional[Any]	    =	len(lowercase_					)
       _UpperCamelCase  :							Optional[int]	    =	[[0 for i in range(number + 1					)] for j in range(r + 1					)]
       for i in range(r + 1					):
              _UpperCamelCase  :							List[Any]	    =	True

       for i in range(1		,    number + 1					):
              _UpperCamelCase  :							int	    =	False

       for i in range(1		,    r + 1					):
              for j in range(1		,    number + 1					):
                     if j < values[i - 1]:
                            _UpperCamelCase  :							Optional[Any]	    =	subset[i - 1][j]
                     else:
                            _UpperCamelCase  :							List[Any]	    =	subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

       return subset[r][number] != 0


def SCREAMING_SNAKE_CASE					(  lowercase_:						int					):
       return abundant(lowercase_					) and not semi_perfect(lowercase_					)


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)
 for number in (69, 70, 71):
  print(f'''{number} is {"" if weird(number) else "not "}weird.''')








from __future__ import annotations






def 			UpperCAmelCase__     (     lowercase__ )			->   list[int]:
						if not list_of_ints:
												return []

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

						__lowercase											=					max(len(bin(lowercase__ )[2:] ) for x in list_of_ints )
						return _msd_radix_sort(lowercase__    ,							lowercase__ )






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

						__lowercase											=					[]
						__lowercase											=					[]
						# 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
						__lowercase											=					_msd_radix_sort(lowercase__    ,							bit_position - 1 )
						__lowercase											=					_msd_radix_sort(lowercase__    ,							bit_position - 1 )

						# recombine lists
						__lowercase											=					zeros
						res.extend(lowercase__ )

						return res






def 			UpperCAmelCase__     (     lowercase__ )			->   List[Any]:
						__lowercase											=					len(lowercase__ )
						if not list_of_ints or length == 1:
												return

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

						__lowercase											=					max(len(bin(lowercase__ )[2:] ) for x in list_of_ints )
						_msd_radix_sort_inplace(lowercase__    ,							lowercase__    ,							0    ,							lowercase__ )






def 			UpperCAmelCase__     (     lowercase__    ,							lowercase__    ,							lowercase__    ,							lowercase__ )			->   Optional[Any]:
						if bit_position == 0 or end_index - begin_index <= 1:
												return

						bit_position -= 1

						__lowercase											=					begin_index
						__lowercase											=					end_index - 1
						while i <= j:
												__lowercase											=					False
												if not (list_of_ints[i] >> bit_position) & 1:
																		# found zero at the beginning
																		i += 1
																		__lowercase											=					True
												if (list_of_ints[j] >> bit_position) & 1:
																		# found one at the end
																		j -= 1
																		__lowercase											=					True

												if changed:
																		continue

												__lowercase						,      __lowercase											=					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()





