
import math


def     UpperCamelCase      (					__lowerCamelCase  :				int					):
							if n <= 0:
														raise ValueError("Only positive integers have prime factors"					)
							snake_case :     Any           =   []
							while n % 2 == 0:
														pf.append(2					)
														snake_case :     List[Any]           =   int(n / 2					)
							for i in range(3       ,      int(math.sqrt(__lowerCamelCase					)					) + 1       ,      2					):
														while n % i == 0:
																					pf.append(__lowerCamelCase					)
																					snake_case :     Tuple           =   int(n / i					)
							if n > 2:
														pf.append(__lowerCamelCase					)
							return pf


def     UpperCamelCase      (					__lowerCamelCase  :				int					):
							if n <= 0:
														raise ValueError("Only positive numbers are accepted"					)
							snake_case :     Union[str, Any]           =   1
							snake_case :     Optional[int]           =   1
							while n % 2 == 0:
														temp += 1
														snake_case :     List[Any]           =   int(n / 2					)
							div *= temp
							for i in range(3       ,      int(math.sqrt(__lowerCamelCase					)					) + 1       ,      2					):
														snake_case :     Any           =   1
														while n % i == 0:
																					temp += 1
																					snake_case :     int           =   int(n / i					)
														div *= temp
							if n > 1:
														div *= 2
							return div


def     UpperCamelCase      (					__lowerCamelCase  :				int					):
							if n <= 0:
														raise ValueError("Only positive numbers are accepted"					)
							snake_case :     Optional[Any]           =   1
							snake_case :     List[Any]           =   1
							while n % 2 == 0:
														temp += 1
														snake_case :     Any           =   int(n / 2					)
							if temp > 1:
														s *= (2**temp - 1) / (2 - 1)
							for i in range(3       ,      int(math.sqrt(__lowerCamelCase					)					) + 1       ,      2					):
														snake_case :     str           =   1
														while n % i == 0:
																					temp += 1
																					snake_case :     Tuple           =   int(n / i					)
														if temp > 1:
																					s *= (i**temp - 1) / (i - 1)
							return int(__lowerCamelCase					)


def     UpperCamelCase      (					__lowerCamelCase  :				int					):
							snake_case :     Dict           =   n
							for x in set(prime_factors(__lowerCamelCase					)					):
														s *= (x - 1) / x
							return int(__lowerCamelCase					)


if __name__ == "__main__":
			import doctest

			doctest.testmod()







def     UpperCamelCase      (					__lowerCamelCase  :				list       ,      __lowerCamelCase  :				list       ,      __lowerCamelCase  :				list       ,      __lowerCamelCase  :				int       ,      __lowerCamelCase  :				int					):
       if target == 0:
              answer.append(path.copy()					)
       else:
              for index in range(__lowerCamelCase       ,      len(__lowerCamelCase					)					):
                     if target >= candidates[index]:
                            path.append(candidates[index]					)
                            backtrack(__lowerCamelCase       ,      __lowerCamelCase       ,      __lowerCamelCase       ,      target - candidates[index]       ,      __lowerCamelCase					)
                            path.pop(len(__lowerCamelCase					) - 1					)


def     UpperCamelCase      (					__lowerCamelCase  :				list       ,      __lowerCamelCase  :				int					):
       snake_case :     Optional[Any]           =   []  # type: list[int]
       snake_case :     Tuple           =   []  # type: list[int]
       backtrack(__lowerCamelCase       ,      __lowerCamelCase       ,      __lowerCamelCase       ,      __lowerCamelCase       ,      0					)
       return answer


def     UpperCamelCase      (					):
       print(combination_sum([-8, 2.3, 0]       ,      1					)					)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   main()





