


from math import sqrt



def 			_a      (    __UpperCamelCase			):
     a_     :  Dict				      =     [1]
     for i in range(2	,	int(sqrt(__UpperCamelCase			)			) + 1	,	1			):
          if number % i == 0:
               values.append(__UpperCamelCase			)
               if int(number // i			) != i:
                    values.append(int(number // i			)			)
     return sorted(__UpperCamelCase			)



def 			_a      (    __UpperCamelCase			):
     return sum(factors(__UpperCamelCase			)			) > n



def 			_a      (    __UpperCamelCase			):
     a_     :  List[str]				      =     factors(__UpperCamelCase			)
     a_     :  Any				      =     len(__UpperCamelCase			)
     a_     :  Union[str, Any]				      =     [[0 for i in range(number + 1			)] for j in range(r + 1			)]
     for i in range(r + 1			):
          a_     :  Dict				      =     True

     for i in range(1	,	number + 1			):
          a_     :  List[Any]				      =     False

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

     return subset[r][number] != 0



def 			_a      (    __UpperCamelCase			):
     return abundant(__UpperCamelCase			) and not semi_perfect(__UpperCamelCase			)


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







def 			_lowerCAmelCase(      UpperCAmelCase_      :	list					, UpperCAmelCase_      :	int					, UpperCAmelCase_      :	int					, UpperCAmelCase_      :	int						) ->							int:
							lowerCAmelCase__  =   int((lower_bound + upper_bound) // 2						)
							if array[r] == value:
														return r
							if lower_bound >= upper_bound:
														return -1
							if array[r] < value:
														return binary_search(UpperCAmelCase_					, r + 1					, UpperCAmelCase_					, UpperCAmelCase_						)
							else:
														return binary_search(UpperCAmelCase_					, UpperCAmelCase_					, r - 1					, UpperCAmelCase_						)
def 			_lowerCAmelCase(      UpperCAmelCase_      :	int					, UpperCAmelCase_      :	list						) ->							list:
							lowerCAmelCase__  =   0
							if matrix[index][0] == value:
														return [index, 0]
							while index < len(UpperCAmelCase_						) and matrix[index][0] < value:
														lowerCAmelCase__  =   binary_search(matrix[index]					, 0					, len(matrix[index]						) - 1					, UpperCAmelCase_						)
														if r != -1:
																					return [index, r]
														index += 1
							return [-1, -1]


if __name__ == "__main__":
		import doctest

		doctest.testmod()





