
"""simple docstring"""
def 					a__ ( a :					int		):

  """simple docstring"""







  if not isinstance(a							,  a		):
    _snake_case  :    Optional[Any]            = f'Input value of [number={number}] must be an integer'
    raise TypeError(a		)
  if number < 0 or number % 2 == 1:
    return False
  _snake_case  :    Dict            = int(number**0.5		)
  return number == number_sqrt * (number_sqrt + 1)


if __name__ == "__main__":
    import doctest

    doctest.testmod()


from hashlib import mda, shaaaa

snake_case__						      =			(shaaaa, mda)



class 			UpperCamelCase					:

     '''simple docstring'''

     def __init__(       self					,					A_ = 8    )			->					None:






           """simple docstring"""
           _lowerCamelCase           =					0b0
           _lowerCamelCase           =					size



     def 		UpperCamelCase_    (       self					,					A_    )			->					None:






           """simple docstring"""
           _lowerCamelCase           =					self.hash_(A_    )
           self.bitarray |= h



     def 		UpperCamelCase_    (       self					,					A_    )			->					bool:






           """simple docstring"""
           _lowerCamelCase           =					self.hash_(A_    )
           return (h & self.bitarray) == h



     def __contains__(       self					,					A_    )			->					bool:






           """simple docstring"""
           return self.exists(A_    )



     def 		UpperCamelCase_    (       self					,					A_    )			->					str:






           """simple docstring"""
           _lowerCamelCase           =					bin(A_    )[2:]
           return res.zfill(self.size    )



     @property
     def 		UpperCamelCase_    (       self    )			->					str:






           """simple docstring"""
           return self.format_bin(self.bitarray    )



     def 		UpperCamelCase_    (       self					,					A_    )			->					int:






           """simple docstring"""
           _lowerCamelCase           =					0b0
           for func in HASH_FUNCTIONS:
                 _lowerCamelCase           =					(
                     int.from_bytes(func(value.encode()    ).digest()					,					'''little'''    ) % self.size
                 )
                 res |= 2**position
           return res



     def 		UpperCamelCase_    (       self					,					A_    )			->					str:






           """simple docstring"""
           return self.format_bin(self.hash_(A_    )    )





     @property
     def 		UpperCamelCase_    (       self    )			->					float:






           """simple docstring"""
           _lowerCamelCase           =					bin(self.bitarray    ).count('''1'''    )
           return (n_ones / self.size) ** len(A_    )