





'''simple docstring'''

from __future__ import annotations

from collections.abc import MutableSequence

class       UpperCAmelCase :




		def __init__(self      :	Dict							,			A__      :	int							,			A__      :	MutableSequence[float]				)					-> None:
						if len(A__				) != degree + 1:
										raise ValueError(
										    "The number of coefficients should be equal to the degree + 1."				)

						lowercase         = list(A__				)
						lowercase         = degree




		def __add__(self      :	Dict							,			A__      :	Polynomial				)					-> Polynomial:

						if self.degree > polynomial_a.degree:
										lowercase         = self.coefficients[:]
										for i in range(polynomial_a.degree + 1				):
														coefficients[i] += polynomial_a.coefficients[i]
										return Polynomial(self.degree							,			A__				)
						else:
										lowercase         = polynomial_a.coefficients[:]
										for i in range(self.degree + 1				):
														coefficients[i] += self.coefficients[i]
										return Polynomial(polynomial_a.degree							,			A__				)




		def __sub__(self      :	Optional[Any]							,			A__      :	Polynomial				)					-> Polynomial:
						return self + polynomial_a * Polynomial(0							,			[-1]				)




		def __neg__(self      :	Tuple				)					-> Polynomial:
						return Polynomial(self.degree							,			[-c for c in self.coefficients]				)




		def __mul__(self      :	Any							,			A__      :	Polynomial				)					-> Polynomial:
						lowercase         = [0] * (self.degree + polynomial_a.degree + 1)
						for i in range(self.degree + 1				):
										for j in range(polynomial_a.degree + 1				):
														coefficients[i + j] += (
														    self.coefficients[i] * polynomial_a.coefficients[j]
														)

						return Polynomial(self.degree + polynomial_a.degree							,			A__				)




		def 				UpperCAmelCase__   (self      :	List[Any]							,			A__      :	int | float				)					-> int | float:
						lowercase         = 0
						for i in range(self.degree + 1				):
										result += self.coefficients[i] * (substitution**i)
						return result




		def __str__(self      :	int				)					-> str:
						lowercase         = ""
						for i in range(self.degree							,			-1							,			-1				):
										if self.coefficients[i] == 0:
														continue
										elif self.coefficients[i] > 0:
														if polynomial:
																		polynomial += " + "
										else:
														polynomial += " - "

										if i == 0:
														polynomial += str(abs(self.coefficients[i]				)				)
										elif i == 1:
														polynomial += str(abs(self.coefficients[i]				)				) + "x"
										else:
														polynomial += str(abs(self.coefficients[i]				)				) + "x^" + str(A__				)

						return polynomial




		def __repr__(self      :	Any				)					-> str:
						return self.__str__()




		def 				UpperCAmelCase__   (self      :	Union[str, Any]				)					-> Polynomial:
						lowercase         = [0] * self.degree
						for i in range(self.degree				):
										lowercase         = self.coefficients[i + 1] * (i + 1)
						return Polynomial(self.degree - 1							,			A__				)




		def 				UpperCAmelCase__   (self      :	Union[str, Any]							,			A__      :	int | float = 0				)					-> Polynomial:
						lowercase         = [0] * (self.degree + 2)
						lowercase         = constant
						for i in range(self.degree + 1				):
										lowercase         = self.coefficients[i] / (i + 1)
						return Polynomial(self.degree + 1							,			A__				)




		def __eq__(self      :	Union[str, Any]							,			A__      :	object				)					-> bool:
						if not isinstance(A__							,			A__				):
										return False

						if self.degree != polynomial_a.degree:
										return False

						for i in range(self.degree + 1				):
										if self.coefficients[i] != polynomial_a.coefficients[i]:
														return False

						return True





		def __ne__(self      :	Dict							,			A__      :	object				)					-> bool:
						return not self.__eq__(A__				)







'''simple docstring'''

from functools import lru_cache







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				lowercase         = 2
				lowercase         = set()
				while i * i <= n:
								if n % i:
												i += 1
								else:
												n //= i
												factors.add(lowerCAmelCase_							)
				if n > 1:
								factors.add(lowerCAmelCase_							)
				return factors







@lru_cache
def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				return len(unique_prime_factors(lowerCAmelCase_							)							)







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				return len(set(lowerCAmelCase_							)							) in (0, 1)







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				lowercase         = 2

				while True:
								# Increment each value of a generated range
								lowercase         = [base + i for i in range(lowerCAmelCase_							)]

								# Run elements through out unique_prime_factors function
								# Append our target number to the end.
								lowercase         = [upf_len(lowerCAmelCase_							) for x in group]
								checker.append(lowerCAmelCase_							)

								# If all numbers in the list are equal, return the group variable.
								if equality(lowerCAmelCase_							):
												return group

								# Increment our base variable by 1
								base += 1







def 							UpperCAmelCase_    (	lowerCAmelCase_ = 4							):

				"""simple docstring"""






				lowercase         = run(lowerCAmelCase_							)
				return results[0] if len(lowerCAmelCase_							) else None


if __name__ == "__main__":
			print(solution())




