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.''')





'''simple docstring'''





import math
from timeit import timeit

def   A			(							A_				:       int							):
						snake_case							:  List[str]			=     0
						snake_case							:  Any			=     abs(A_							)
						while True:
												snake_case							:  List[Any]			=     n // 10
												digits += 1
												if n == 0:
																		break
						return digits

def   A			(							A_				:       int							):
						return 1 if n == 0 else math.floor(math.log(abs(A_							)     ,				10							) + 1							)

def   A			(							A_				:       int							):
						return len(str(abs(A_							)							)							)

def   A			(							):
						from collections.abc import Callable

						def benchmark_a_function(A_				:       Callable     ,				A_				:       int							) -> None:
												snake_case							:  Optional[int]			=     F"""{func.__name__}({value})"""
												snake_case							:  Optional[int]			=     timeit(F"""__main__.{call}"""     ,				setup='''import __main__'''							)
												print(F"""{call}: {func(A_							)} -- {timing} seconds"""							)

						for value in (262144, 1125899906842624, 1267650600228229401496703205376):
												for func in (num_digits, num_digits_fast, num_digits_faster):
																		benchmark_a_function(A_     ,				A_							)
												print()


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						benchmark()

