



from math import sqrt







def  lowerCAmelCase_	(lowerCAmelCase__:		int  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (
			    number >= 0
			), "'number' must been an int and positive"

			UpperCAmelCase_:		Dict							      =     True

			# 0 and 1 are none primes.
			if number <= 1:
						UpperCAmelCase_:		int							      =     False

			for divisor in range(2		,						int(round(sqrt(lowerCAmelCase__  )  )  ) + 1  ):
						# if 'number' divisible by 'divisor' then sets 'status'
						# of false and break up the loop.
						if number % divisor == 0:
									UpperCAmelCase_:		Optional[int]							      =     False
									break

    # precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'status' must been from type bool"

			return status







def  lowerCAmelCase_	(lowerCAmelCase__:		Dict  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (n > 2), "'N' must been an int and > 2"

			# beginList: contains all natural numbers from 2 up to N
			UpperCAmelCase_:		Optional[Any]							      =     list(range(2		,						n + 1  )  )

			UpperCAmelCase_:		List[str]							      =     []  # this list will be returns.

			# actual sieve of erathostenes
			for i in range(len(lowerCAmelCase__  )  ):
						for j in range(i + 1		,						len(lowerCAmelCase__  )  ):
									if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
												UpperCAmelCase_:		List[Any]							      =     0

    # filters actual prime numbers.
			UpperCAmelCase_:		str							      =     [x for x in begin_list if x != 0]

			# precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'ans' must been from type list"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		Optional[Any]  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (n > 2), "'N' must been an int and > 2"

			UpperCAmelCase_:		Any							      =     []

			# iterates over all numbers between 2 up to N+1
			# if a number is prime then appends to list 'ans'
			for number in range(2		,						n + 1  ):
						if is_prime(lowerCAmelCase__  ):
									ans.append(lowerCAmelCase__  )

    # precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'ans' must been from type list"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		int  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and number >= 0, "'number' must been an int and >= 0"

			UpperCAmelCase_:		int							      =     []  # this list will be returns of the function.

			# potential prime number factors.

			UpperCAmelCase_:		int							      =     2

			UpperCAmelCase_:		List[Any]							      =     number

			if number == 0 or number == 1:
						ans.append(lowerCAmelCase__  )

			# if 'number' not prime then builds the prime factorization of 'number'
			elif not is_prime(lowerCAmelCase__  ):
						while quotient != 1:
									if is_prime(lowerCAmelCase__  ) and (quotient % factor == 0):
												ans.append(lowerCAmelCase__  )
												quotient /= factor
									else:
												factor += 1

			else:
						ans.append(lowerCAmelCase__  )

			# precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'ans' must been from type list"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		List[Any]  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			UpperCAmelCase_:		str							      =     0

			# prime factorization of 'number'
			UpperCAmelCase_:		Union[str, Any]							      =     prime_factorization(lowerCAmelCase__  )

			UpperCAmelCase_:		str							      =     max(lowerCAmelCase__  )

			# precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'ans' must been from type int"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		Dict  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			UpperCAmelCase_:		Tuple							      =     0

			# prime factorization of 'number'
			UpperCAmelCase_:		List[str]							      =     prime_factorization(lowerCAmelCase__  )

			UpperCAmelCase_:		int							      =     min(lowerCAmelCase__  )

			# precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'ans' must been from type int"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		Any  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'number' must been an int"
			assert isinstance(number % 2 == 0		,						lowerCAmelCase__  ), "compare bust been from type bool"

			return number % 2 == 0







def  lowerCAmelCase_	(lowerCAmelCase__:		Union[str, Any]  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ), "'number' must been an int"
			assert isinstance(number % 2 != 0		,						lowerCAmelCase__  ), "compare bust been from type bool"

			return number % 2 != 0







def  lowerCAmelCase_	(lowerCAmelCase__:		int  ):





			"""simple docstring"""


			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (number > 2) and is_even(lowerCAmelCase__  )
			), "'number' must been an int, even and > 2"

			UpperCAmelCase_:		List[str]							      =     []  # this list will returned

			# creates a list of prime numbers between 2 up to 'number'
			UpperCAmelCase_:		Union[str, Any]							      =     get_prime_numbers(lowerCAmelCase__  )
			UpperCAmelCase_:		List[Any]							      =     len(lowerCAmelCase__  )

			# run variable for while-loops.
			UpperCAmelCase_:		List[str]							      =     0
			UpperCAmelCase_:		List[str]							      =     None

			# exit variable. for break up the loops
			UpperCAmelCase_:		Any							      =     True

			while i < len_pn and loop:
						UpperCAmelCase_:		Any							      =     i + 1

						while j < len_pn and loop:
									if prime_numbers[i] + prime_numbers[j] == number:
												UpperCAmelCase_:		int							      =     False
												ans.append(prime_numbers[i]  )
												ans.append(prime_numbers[j]  )

									j += 1

						i += 1

			# precondition
			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and (len(lowerCAmelCase__  ) == 2)
			    and (ans[0] + ans[1] == number)
			    and is_prime(ans[0]  )
			    and is_prime(ans[1]  )
			), "'ans' must contains two primes. And sum of elements must been eq 'number'"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		Union[str, Any]		,						lowerCAmelCase__:		Optional[int]  ):





			"""simple docstring"""


			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and (numbera >= 0)
			    and (numbera >= 0)
			), "'number1' and 'number2' must been positive integer."

			UpperCAmelCase_:		int							      =     0

			while numbera != 0:
						UpperCAmelCase_:		Dict							      =     numbera % numbera
						UpperCAmelCase_:		Tuple							      =     numbera
						UpperCAmelCase_:		int							      =     rest

			# precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (
			    numbera >= 0
			), "'number' must been from type int and positive"

			return numbera







def  lowerCAmelCase_	(lowerCAmelCase__:		Union[str, Any]		,						lowerCAmelCase__:		str  ):





			"""simple docstring"""


			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and (numbera >= 1)
			    and (numbera >= 1)
			), "'number1' and 'number2' must been positive integer."

			UpperCAmelCase_:		str							      =     1  # actual answer that will be return.

			# for kgV (x,1)
			if numbera > 1 and numbera > 1:
						# builds the prime factorization of 'number1' and 'number2'
						UpperCAmelCase_:		Any							      =     prime_factorization(lowerCAmelCase__  )
						UpperCAmelCase_:		List[Any]							      =     prime_factorization(lowerCAmelCase__  )

			elif numbera == 1 or numbera == 1:
						UpperCAmelCase_:		List[str]							      =     []
						UpperCAmelCase_:		Optional[Any]							      =     []
						UpperCAmelCase_:		List[str]							      =     max(lowerCAmelCase__		,						lowerCAmelCase__  )

			UpperCAmelCase_:		Optional[int]							      =     0
			UpperCAmelCase_:		Optional[int]							      =     0

			UpperCAmelCase_:		Any							      =     []  # captured numbers int both 'primeFac1' and 'primeFac2'

			# iterates through primeFac1
			for n in prime_fac_a:
						if n not in done:
									if n in prime_fac_a:
												UpperCAmelCase_:		List[Any]							      =     prime_fac_a.count(lowerCAmelCase__  )
												UpperCAmelCase_:		str							      =     prime_fac_a.count(lowerCAmelCase__  )

												for _ in range(max(lowerCAmelCase__		,						lowerCAmelCase__  )  ):
															ans *= n

									else:
												UpperCAmelCase_:		Optional[Any]							      =     prime_fac_a.count(lowerCAmelCase__  )

												for _ in range(lowerCAmelCase__  ):
															ans *= n

									done.append(lowerCAmelCase__  )

    # iterates through primeFac2
			for n in prime_fac_a:
						if n not in done:
									UpperCAmelCase_:		Tuple							      =     prime_fac_a.count(lowerCAmelCase__  )

									for _ in range(lowerCAmelCase__  ):
												ans *= n

									done.append(lowerCAmelCase__  )

    # precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (
			    ans >= 0
			), "'ans' must been from type int and positive"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		List[Any]  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (n >= 0), "'number' must been a positive int"

			UpperCAmelCase_:		List[str]							      =     0
			UpperCAmelCase_:		Union[str, Any]							      =     2  # this variable holds the answer

			while index < n:
						index += 1

						ans += 1  # counts to the next number

						# if ans not prime then
						# runs to the next prime number.
						while not is_prime(lowerCAmelCase__  ):
									ans += 1

    # precondition
			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and is_prime(
			    lowerCAmelCase__  ), "'ans' must been a prime number and from type int"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		int		,						lowerCAmelCase__:		Optional[Any]  ):





			"""simple docstring"""


			assert (
			    is_prime(lowerCAmelCase__  ) and is_prime(lowerCAmelCase__  ) and (p_number_a < p_number_a)
			), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

			UpperCAmelCase_:		Union[str, Any]							      =     p_number_a + 1  # jump to the next number

			UpperCAmelCase_:		Optional[int]							      =     []  # this list will be returns.

			# if number is not prime then
			# fetch the next prime number.
			while not is_prime(lowerCAmelCase__  ):
						number += 1

			while number < p_number_a:
						ans.append(lowerCAmelCase__  )

						number += 1

						# fetch the next prime number.
						while not is_prime(lowerCAmelCase__  ):
									number += 1

    # precondition
			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and ans[0] != p_number_a
			    and ans[len(lowerCAmelCase__  ) - 1] != p_number_a
			), "'ans' must been a list without the arguments"

			# 'ans' contains not 'pNumber1' and 'pNumber2' !
			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		List[Any]  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (n >= 1), "'n' must been int and >= 1"

			UpperCAmelCase_:		Tuple							      =     []  # will be returned.

			for divisor in range(1		,						n + 1  ):
						if n % divisor == 0:
									ans.append(lowerCAmelCase__  )

    # precondition
			assert ans[0] == 1 and ans[len(lowerCAmelCase__  ) - 1] == n, "Error in function getDivisiors(...)"

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		Tuple  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (
			    number > 1
			), "'number' must been an int and >= 1"

			UpperCAmelCase_:		List[str]							      =     get_divisors(lowerCAmelCase__  )

			# precondition
			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and (divisors[0] == 1)
			    and (divisors[len(lowerCAmelCase__  ) - 1] == number)
			), "Error in help-function getDivisiors(...)"

			# summed all divisors up to 'number' (exclusive), hence [:-1]
			return sum(divisors[:-1]  ) == number







def  lowerCAmelCase_	(lowerCAmelCase__:		List[Any]		,						lowerCAmelCase__:		List[str]  ):





			"""simple docstring"""


			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and (denominator != 0)
			), "The arguments must been from type int and 'denominator' != 0"

			# build the greatest common divisor of numerator and denominator.
			UpperCAmelCase_:		Optional[int]							      =     gcd(abs(lowerCAmelCase__  )		,						abs(lowerCAmelCase__  )  )

			# precondition
			assert (
			    isinstance(lowerCAmelCase__		,						lowerCAmelCase__  )
			    and (numerator % gcd_of_fraction == 0)
			    and (denominator % gcd_of_fraction == 0)
			), "Error in function gcd(...,...)"

			return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)







def  lowerCAmelCase_	(lowerCAmelCase__:		List[Any]  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (n >= 0), "'n' must been a int and >= 0"

			UpperCAmelCase_:		List[Any]							      =     1  # this will be return.

			for factor in range(1		,						n + 1  ):
						ans *= factor

			return ans







def  lowerCAmelCase_	(lowerCAmelCase__:		Tuple  ):





			"""simple docstring"""


			assert isinstance(lowerCAmelCase__		,						lowerCAmelCase__  ) and (n >= 0), "'n' must been an int and >= 0"

			UpperCAmelCase_:		List[str]							      =     0
			UpperCAmelCase_:		Tuple							      =     1
			UpperCAmelCase_:		Dict							      =     1  # this will be return

			for _ in range(n - 1  ):
						UpperCAmelCase_:		List[Any]							      =     ans
						ans += fiba
						UpperCAmelCase_:		Dict							      =     tmp

			return ans











def  lowerCAmelCase_	(lowerCAmelCase__:		list  ):





			"""simple docstring"""


			if len(lowerCAmelCase__  ) <= 1:
						return [tuple(lowerCAmelCase__  )]

			UpperCAmelCase_:		List[Any]							      =     []

			def generate(lowerCAmelCase__:		int		,						lowerCAmelCase__:		list  ):
						if k == 1:
									res.append(tuple(arr[:]  )  )
									return

						generate(k - 1		,						lowerCAmelCase__  )

						for i in range(k - 1  ):
									if k % 2 == 0:  # k is even
												UpperCAmelCase_      ,							UpperCAmelCase_:		Union[str, Any]							      =     arr[k - 1], arr[i]
									else:  # k is odd
												UpperCAmelCase_      ,							UpperCAmelCase_:		Optional[int]							      =     arr[k - 1], arr[0]
									generate(k - 1		,						lowerCAmelCase__  )

			generate(len(lowerCAmelCase__  )		,						lowerCAmelCase__  )
			return res


if __name__ == "__main__":
	a      :  Optional[Any]			     =			input('Enter numbers separated by a comma:\n').strip()
	a      :  str			     =			[int(item) for item in user_input.split(',')]
	print(heaps(arr))






