





from math import sqrt




def 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		list[int]:
       UpperCamelCase_ 							=	[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 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		bool:
       return sum(factors(UpperCamelCase_	)	) > n




def 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		bool:
       UpperCamelCase_ 							=	factors(UpperCamelCase_	)
       UpperCamelCase_ 							=	len(UpperCamelCase_	)
       UpperCamelCase_ 							=	[[0 for i in range(number + 1	)] for j in range(r + 1	)]
       for i in range(r + 1	):
              UpperCamelCase_ 							=	True

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

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

       return subset[r][number] != 0




def 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		bool:
       return abundant(UpperCamelCase_	) and not semi_perfect(UpperCamelCase_	)


if __name__ == "__main__":
     import doctest

     doctest.testmod(verbose=True)
     for number in (6_9, 7_0, 7_1):
          print(f'''{number} is {'' if weird(number) else 'not '}weird.''')


from hashlib import mda, shaaaa

__lowerCamelCase     :					Dict				  =						(shaaaa, mda)







class __snake_case							:




   def __init__(       self     :							str			,      _lowercase     :							int = 8 ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= 0B0
     SCREAMING_SNAKE_CASE__     				= size




   def       __a		(       self     :							List[str]			,      _lowercase     :							str ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= self.hash_(_lowercase )
     self.bitarray |= h




   def       __a		(       self     :							int			,      _lowercase     :							str ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= self.hash_(_lowercase )
     return (h & self.bitarray) == h




   def __contains__(       self     :							Union[str, Any]			,      _lowercase     :							str ):



     """simple docstring"""






     return self.exists(_lowercase )




   def       __a		(       self     :							Dict			,      _lowercase     :							int ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= bin(_lowercase )[2:]
     return res.zfill(self.size )




   @property
   def       __a		(       self     :							Tuple ):



     """simple docstring"""






     return self.format_bin(self.bitarray )




   def       __a		(       self     :							Optional[int]			,      _lowercase     :							str ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= 0B0
     for func in HASH_FUNCTIONS:
       SCREAMING_SNAKE_CASE__     				= (
           int.from_bytes(func(value.encode() ).digest()			,      """little""" ) % self.size
       )
       res |= 2**position
     return res




   def       __a		(       self     :							str			,      _lowercase     :							str ):



     """simple docstring"""






     return self.format_bin(self.hash_(_lowercase ) )




   @property
   def       __a		(       self     :							Union[str, Any] ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__     				= bin(self.bitarray ).count("""1""" )
     return (n_ones / self.size) ** len(_lowercase )
