__lowerCamelCase     :					Optional[int]				  =						1000



def       __SCREAMING_SNAKE_CASE    (   __UpperCamelCase       :			float      )				->   float:







  """simple docstring"""





  return x * x



def       __SCREAMING_SNAKE_CASE    (   __UpperCamelCase       :			Any					,	__UpperCamelCase       :			float					,	__UpperCamelCase       :			float					,	__UpperCamelCase       :			int = 4      )				->   float:







  """simple docstring"""





  assert callable(
      __UpperCamelCase      ), f"""the function(object) passed should be callable your input : {function}"""
  assert isinstance(__UpperCamelCase					,	(float, int)      ), f"""a should be float or integer your input : {a}"""
  assert isinstance(function(__UpperCamelCase      )					,	(float, int)      ), (
      "the function should return integer or float return type of your function, "
      f"""{type(__UpperCamelCase      )}"""
  )
  assert isinstance(__UpperCamelCase					,	(float, int)      ), f"""b should be float or integer your input : {b}"""
  assert (
      isinstance(__UpperCamelCase					,	__UpperCamelCase      ) and precision > 0
  ), f"""precision should be positive integer your input : {precision}"""

  # just applying the formula of simpson for approximate integration written in
  # mentioned article in first comment of this file and above this function

  SCREAMING_SNAKE_CASE__     				= (b - a) / N_STEPS
  SCREAMING_SNAKE_CASE__     				= function(__UpperCamelCase      ) + function(__UpperCamelCase      )

  for i in range(1					,	__UpperCamelCase      ):
    SCREAMING_SNAKE_CASE__     				= a + h * i
    result += function(__UpperCamelCase      ) * (4 if i % 2 else 2)

  result *= h / 3
  return round(__UpperCamelCase					,	__UpperCamelCase      )


if __name__ == "__main__":
   import doctest

   doctest.testmod()

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 )
