def   a_					(_lowerCAmelCase  :   Optional[Any]       )->				str:
    if not isinstance(_lowerCAmelCase			,	_lowerCAmelCase       ):
        snake_case:						Any         =   (
            'operation can not be conducted on a object of type '
            F"{type(_lowerCAmelCase       ).__name__}"
        )
        raise TypeError(_lowerCAmelCase       )
    snake_case:						Tuple         =   ''
    for _ in range(0			,	32       ):
        bit_string += str(number % 2       )
        snake_case:						Optional[Any]         =   number >> 1
    return bit_string

def   a_					(_lowerCAmelCase  :   int       )->				str:
    if number < 0:
        raise ValueError("""the value of input must be positive"""       )
    elif isinstance(_lowerCAmelCase			,	_lowerCAmelCase       ):
        raise TypeError("""Input value must be a \'int\' type"""       )
    elif isinstance(_lowerCAmelCase			,	_lowerCAmelCase       ):
        raise TypeError("""\'<\' not supported between instances of \'str\' and \'int\'"""       )
    snake_case:						List[str]         =   0
    # iterator over [1 to 32],since we are dealing with 32 bit integer
    for _ in range(1			,	33       ):
        # left shift the bits by unity
        snake_case:						List[str]         =   result << 1
        # get the end bit
        snake_case:						Dict         =   number % 2
        # right shift the bits by unity
        snake_case:						Optional[Any]         =   number >> 1
        # add that bit to our ans
        snake_case:						int         =   result | end_bit
    return get_reverse_bit_string(_lowerCAmelCase       )


if __name__ == "__main__":
    import doctest

    doctest.testmod()






from .hash_table import HashTable
from .number_theory.prime_numbers import is_prime, next_prime





class     __a     (       __UpperCamelCase ):
 def __init__(  self							,					*lowerCAmelCase__							,					**lowerCAmelCase__					)   ->							Any:




        '''simple docstring'''
        super().__init__(*lowerCAmelCase__							,					**lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							Union[str, Any]:




        '''simple docstring'''
        lowercase__:  str         =  (
            next_prime(value % self.size_table					)
            if not is_prime(value % self.size_table					)
            else value % self.size_table
        )  # gt = bigger than
        return next_prime_gt - (data % next_prime_gt)
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							Union[str, Any]:




        '''simple docstring'''
        return (increment * self.__hash_function_a(lowerCAmelCase__							,					lowerCAmelCase__					)) % self.size_table
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__=None					)   ->							str:




        '''simple docstring'''
        lowercase__:  Dict         =  1
        lowercase__:  str         =  self.hash_function(lowerCAmelCase__					)

        while self.values[new_key] is not None and self.values[new_key] != key:
               lowercase__:  List[Any]         =  (
                   self.__hash_double_function(lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)
                   if self.balanced_factor() >= self.lim_charge
                   else None
               )
               if new_key is None:
                      break
               else:
                      i += 1

        return new_key


