






from hashlib import mda, shaaaa

_lowerCAmelCase							:      int						=	(shaaaa, mda)


class 					__magic_name__  :





     """simple docstring"""



     def __init__(							self       :List[Any]			,      snake_case       :Optional[Any] = 8  ):





        '''simple docstring'''




        A_					:				Any          =			0B0
        A_					:				List[str]          =			size



     def 						SCREAMING_SNAKE_CASE		(							self       :Tuple			,      snake_case       :List[Any]  ):





        '''simple docstring'''




        A_					:				List[Any]          =			self.hash_(lowercase_  )
        self.bitarray |= h



     def 						SCREAMING_SNAKE_CASE		(							self       :Any			,      snake_case       :Dict  ):





        '''simple docstring'''




        A_					:				Any          =			self.hash_(lowercase_  )
        return (h & self.bitarray) == h



     def __contains__(							self       :List[Any]			,      snake_case       :Optional[int]  ):





        '''simple docstring'''




        return self.exists(lowercase_  )



     def 						SCREAMING_SNAKE_CASE		(							self       :Union[str, Any]			,      snake_case       :Tuple  ):





        '''simple docstring'''




        A_					:				Optional[int]          =			bin(lowercase_  )[2:]
        return res.zfill(self.size  )



     @property
     def 						SCREAMING_SNAKE_CASE		(							self       :List[str]  ):





        '''simple docstring'''




        return self.format_bin(self.bitarray  )



     def 						SCREAMING_SNAKE_CASE		(							self       :List[Any]			,      snake_case       :str  ):





        '''simple docstring'''




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



     def 						SCREAMING_SNAKE_CASE		(							self       :List[str]			,      snake_case       :Tuple  ):





        '''simple docstring'''




        return self.format_bin(self.hash_(lowercase_  )  )





     @property
     def 						SCREAMING_SNAKE_CASE		(							self       :List[Any]  ):





        '''simple docstring'''




        A_					:				str          =			bin(self.bitarray  ).count("1"  )
        return (n_ones / self.size) ** len(lowercase_  )







def      __snake_case						(					_lowerCAmelCase : float				,				_lowerCAmelCase : float				,				_lowerCAmelCase : int	) ->						float:
   A_					:				List[str]          =			[1 / first_term]
   A_					:				Tuple          =			1 / first_term
   for _ in range(number_of_terms - 1	):
      first_term += common_difference
      arithmetic_progression.append(_lowerCAmelCase	)
   A_					:				List[str]          =			[1 / step for step in arithmetic_progression]
   return sum(_lowerCAmelCase	)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(sum_of_harmonic_progression(1 / 2, 2, 2))
