






'''simple docstring'''







from math import sqrt





def 		_UpperCAmelCase (				__A				: int   ):
				assert isinstance(__A    ,		__A   ) and (
				    number >= 0
				), "'number' must been an int and positive"

				a_		:	Union[str, Any]									=   True

				# 0 and 1 are none primes.
				if number <= 1:
								a_		:	Any									=   False

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

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

				return status





def 		_UpperCAmelCase (				__A				: Any   ):
				assert isinstance(__A    ,		__A   ) and (n > 2), "'N' must been an int and > 2"

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

				a_		:	Optional[Any]									=   []  # this list will be returns.

				# actual sieve of erathostenes
				for i in range(len(__A   )   ):
								for j in range(i + 1    ,		len(__A   )   ):
												if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
																a_		:	str									=   0

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

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

				return ans





def 		_UpperCAmelCase (				__A				: Any   ):
				assert isinstance(__A    ,		__A   ) and (n > 2), "'N' must been an int and > 2"

				a_		:	Union[str, 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(__A   ):
												ans.append(__A   )

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

				return ans





def 		_UpperCAmelCase (				__A				: Tuple   ):
				assert isinstance(__A    ,		__A   ) and number >= 0, "'number' must been an int and >= 0"

				a_		:	Any									=   []  # this list will be returns of the function.

				# potential prime number factors.

				a_		:	Union[str, Any]									=   2

				a_		:	int									=   number

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

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

				else:
								ans.append(__A   )

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

				return ans





def 		_UpperCAmelCase (				__A				: int   ):
				assert isinstance(__A    ,		__A   ) and (
				    number >= 0
				), "'number' bust been an int and >= 0"

				a_		:	Optional[Any]									=   0

				# prime factorization of 'number'
				a_		:	Dict									=   prime_factorization(__A   )

				a_		:	str									=   max(__A   )

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

				return ans





def 		_UpperCAmelCase (				__A				: Tuple   ):
				assert isinstance(__A    ,		__A   ) and (
				    number >= 0
				), "'number' bust been an int and >= 0"

				a_		:	int									=   0

				# prime factorization of 'number'
				a_		:	Any									=   prime_factorization(__A   )

				a_		:	Union[str, Any]									=   min(__A   )

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

				return ans





def 		_UpperCAmelCase (				__A				: List[str]   ):
				assert isinstance(__A    ,		__A   ), "'number' must been an int"
				assert isinstance(number % 2 == 0    ,		__A   ), "compare bust been from type bool"

				return number % 2 == 0





def 		_UpperCAmelCase (				__A				: List[str]   ):
				assert isinstance(__A    ,		__A   ), "'number' must been an int"
				assert isinstance(number % 2 != 0    ,		__A   ), "compare bust been from type bool"

				return number % 2 != 0





def 		_UpperCAmelCase (				__A				: Any   ):
				assert (
				    isinstance(__A    ,		__A   ) and (number > 2) and is_even(__A   )
				), "'number' must been an int, even and > 2"

				a_		:	Any									=   []  # this list will returned

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

				# run variable for while-loops.
				a_		:	List[Any]									=   0
				a_		:	Union[str, Any]									=   None

				# exit variable. for break up the loops
				a_		:	Union[str, Any]									=   True

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

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

												j += 1

								i += 1

				# precondition
				assert (
				    isinstance(__A    ,		__A   )
				    and (len(__A   ) == 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 		_UpperCAmelCase (				__A				: Tuple    ,		__A				: Dict   ):
				assert (
				    isinstance(__A    ,		__A   )
				    and isinstance(__A    ,		__A   )
				    and (numbera >= 0)
				    and (numbera >= 0)
				), "'number1' and 'number2' must been positive integer."

				a_		:	Dict									=   0

				while numbera != 0:
								a_		:	List[str]									=   numbera % numbera
								a_		:	Tuple									=   numbera
								a_		:	Tuple									=   rest

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

				return numbera





def 		_UpperCAmelCase (				__A				: Tuple    ,		__A				: str   ):
				assert (
				    isinstance(__A    ,		__A   )
				    and isinstance(__A    ,		__A   )
				    and (numbera >= 1)
				    and (numbera >= 1)
				), "'number1' and 'number2' must been positive integer."

				a_		:	List[Any]									=   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'
								a_		:	int									=   prime_factorization(__A   )
								a_		:	Union[str, Any]									=   prime_factorization(__A   )

				elif numbera == 1 or numbera == 1:
								a_		:	Dict									=   []
								a_		:	Dict									=   []
								a_		:	str									=   max(__A    ,		__A   )

				a_		:	List[Any]									=   0
				a_		:	Union[str, Any]									=   0

				a_		:	Union[str, 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:
																a_		:	List[str]									=   prime_fac_a.count(__A   )
																a_		:	Optional[Any]									=   prime_fac_a.count(__A   )

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

												else:
																a_		:	Tuple									=   prime_fac_a.count(__A   )

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

												done.append(__A   )

    # iterates through primeFac2
				for n in prime_fac_a:
								if n not in done:
												a_		:	Union[str, Any]									=   prime_fac_a.count(__A   )

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

												done.append(__A   )

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

				return ans





def 		_UpperCAmelCase (				__A				: Dict   ):
				assert isinstance(__A    ,		__A   ) and (n >= 0), "'number' must been a positive int"

				a_		:	Any									=   0
				a_		:	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(__A   ):
												ans += 1

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

				return ans





def 		_UpperCAmelCase (				__A				: List[str]    ,		__A				: List[Any]   ):
				assert (
				    is_prime(__A   ) and is_prime(__A   ) and (p_number_a < p_number_a)
				), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

				a_		:	str									=   p_number_a + 1  # jump to the next number

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

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

				while number < p_number_a:
								ans.append(__A   )

								number += 1

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

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

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





def 		_UpperCAmelCase (				__A				: int   ):
				assert isinstance(__A    ,		__A   ) and (n >= 1), "'n' must been int and >= 1"

				a_		:	int									=   []  # will be returned.

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

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

				return ans





def 		_UpperCAmelCase (				__A				: Optional[int]   ):
				assert isinstance(__A    ,		__A   ) and (
				    number > 1
				), "'number' must been an int and >= 1"

				a_		:	Union[str, Any]									=   get_divisors(__A   )

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

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





def 		_UpperCAmelCase (				__A				: Dict    ,		__A				: Optional[Any]   ):
				assert (
				    isinstance(__A    ,		__A   )
				    and isinstance(__A    ,		__A   )
				    and (denominator != 0)
				), "The arguments must been from type int and 'denominator' != 0"

				# build the greatest common divisor of numerator and denominator.
				a_		:	Dict									=   gcd(abs(__A   )    ,		abs(__A   )   )

				# precondition
				assert (
				    isinstance(__A    ,		__A   )
				    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 		_UpperCAmelCase (				__A				: Optional[int]   ):
				assert isinstance(__A    ,		__A   ) and (n >= 0), "'n' must been a int and >= 0"

				a_		:	List[str]									=   1  # this will be return.

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

				return ans





def 		_UpperCAmelCase (				__A				: int   ):
				assert isinstance(__A    ,		__A   ) and (n >= 0), "'n' must been an int and >= 0"

				a_		:	int									=   0
				a_		:	str									=   1
				a_		:	List[str]									=   1  # this will be return

				for _ in range(n - 1   ):
								a_		:	Union[str, Any]									=   ans
								ans += fiba
								a_		:	Tuple									=   tmp

				return ans












'''simple docstring'''







def 		_UpperCAmelCase (				__A				: int   ):
				a_		:	Optional[Any]									=   []
				a_		:	Optional[Any]									=   []
				a_		:	List[str]									=   {
				    '''^''': 3,
				    '''*''': 2,
				    '''/''': 2,
				    '''%''': 2,
				    '''+''': 1,
				    '''-''': 1,
				}  # Priority of each operator
				a_		:	int									=   len(__A   ) if (len(__A   ) > 7) else 7

				# Print table header for output
				print(
				    '''Symbol'''.center(8   )    ,		'''Stack'''.center(__A   )    ,		'''Postfix'''.center(__A   )    ,		sep=''' | '''    ,		)
				print('''-''' * (print_width * 3 + 7)   )

				for x in infix:
								if x.isalpha() or x.isdigit():
												post_fix.append(__A   )  # if x is Alphabet / Digit, add it to Postfix
								elif x == "(":
												stack.append(__A   )  # if x is "(" push to Stack
								elif x == ")":  # if x is ")" pop stack until "(" is encountered
												while stack[-1] != "(":
																post_fix.append(stack.pop()   )  # Pop stack & add the content to Postfix
												stack.pop()
								else:
												if len(__A   ) == 0:
																stack.append(__A   )  # If stack is empty, push x to stack
												else:  # while priority of x is not > priority of element in the stack
																while len(__A   ) > 0 and priority[x] <= priority[stack[-1]]:
																				post_fix.append(stack.pop()   )  # pop stack & add to Postfix
																stack.append(__A   )  # push x to stack

								print(
								    x.center(8   )    ,		(''''''.join(__A   )).ljust(__A   )    ,		(''''''.join(__A   )).ljust(__A   )    ,		sep=''' | '''    ,		)  # Output in tabular format

				while len(__A   ) > 0:  # while stack is not empty
								post_fix.append(stack.pop()   )  # pop stack & add to Postfix
								print(
								    ''' '''.center(8   )    ,		(''''''.join(__A   )).ljust(__A   )    ,		(''''''.join(__A   )).ljust(__A   )    ,		sep=''' | '''    ,		)  # Output in tabular format

				return "".join(__A   )  # return Postfix as str





def 		_UpperCAmelCase (				__A				: Tuple   ):
				a_		:	Union[str, Any]									=   list(infix[::-1]   )  # reverse the infix equation

				for i in range(len(__A   )   ):
								if infix[i] == "(":
												a_		:	List[str]									=   ''')'''  # change "(" to ")"
								elif infix[i] == ")":
												a_		:	str									=   '''('''  # change ")" to "("

				return (infix_2_postfix(''''''.join(__A   )   ))[
				    ::-1
				]  # call infix_2_postfix on Infix, return reverse of Postfix


if __name__ == "__main__":
		__lowerCAmelCase									=   input('\nEnter an Infix Equation = ')  # Input an Infix equation
		__lowerCAmelCase									=   ''.join(Infix.split())  # Remove spaces from the input
		print('\n\t', Infix, '(Infix) -> ', infix_2_prefix(Infix), '(Prefix)')




