


import math
def 							_UpperCAmelCase    (UpperCamelCase__					:  int						):
       if n <= 0:
              raise ValueError("Only positive integers have prime factors"						)
       _A				:	str       =			[]
       while n % 2 == 0:
              pf.append(2						)
              _A				:	str       =			int(n / 2						)
       for i in range(3    ,							int(math.sqrt(UpperCamelCase__						)						) + 1    ,							2						):
              while n % i == 0:
                     pf.append(UpperCamelCase__						)
                     _A				:	Union[str, Any]       =			int(n / i						)
       if n > 2:
              pf.append(UpperCamelCase__						)
       return pf
def 							_UpperCAmelCase    (UpperCamelCase__					:  int						):
       if n <= 0:
              raise ValueError("Only positive numbers are accepted"						)
       _A				:	Optional[Any]       =			1
       _A				:	str       =			1
       while n % 2 == 0:
              temp += 1
              _A				:	Tuple       =			int(n / 2						)
       div *= temp
       for i in range(3    ,							int(math.sqrt(UpperCamelCase__						)						) + 1    ,							2						):
              _A				:	int       =			1
              while n % i == 0:
                     temp += 1
                     _A				:	List[Any]       =			int(n / i						)
              div *= temp
       if n > 1:
              div *= 2
       return div
def 							_UpperCAmelCase    (UpperCamelCase__					:  int						):
       if n <= 0:
              raise ValueError("Only positive numbers are accepted"						)
       _A				:	Union[str, Any]       =			1
       _A				:	List[Any]       =			1
       while n % 2 == 0:
              temp += 1
              _A				:	Dict       =			int(n / 2						)
       if temp > 1:
              s *= (2**temp - 1) / (2 - 1)
       for i in range(3    ,							int(math.sqrt(UpperCamelCase__						)						) + 1    ,							2						):
              _A				:	List[Any]       =			1
              while n % i == 0:
                     temp += 1
                     _A				:	str       =			int(n / i						)
              if temp > 1:
                     s *= (i**temp - 1) / (i - 1)
       return int(UpperCamelCase__						)
def 							_UpperCAmelCase    (UpperCamelCase__					:  int						):
       _A				:	str       =			n
       for x in set(prime_factors(UpperCamelCase__						)						):
              s *= (x - 1) / x
       return int(UpperCamelCase__						)


if __name__ == "__main__":
    import doctest

    doctest.testmod()




def 							_UpperCAmelCase    (UpperCamelCase__					:  str						):
       _A				:	Tuple       =			str(UpperCamelCase__						).strip()
       if not bin_string:
              raise ValueError("Empty string was passed to the function"						)
       _A				:	Dict       =			bin_string[0] == "-"
       if is_negative:
              _A				:	Any       =			bin_string[1:]
       if not all(char in "01" for char in bin_string						):
              raise ValueError("Non-binary value was passed to the function"						)
       _A				:	Union[str, Any]       =			0
       for char in bin_string:
              _A				:	Union[str, Any]       =			2 * decimal_number + int(UpperCamelCase__						)
       return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
    from doctest import testmod

    testmod()
