


from __future__ import annotations

from collections.abc import MutableSequence

class     a		:




							"""simple docstring"""


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

														__snake_case		:      list[float]										=       list(lowerCamelCase    )
														__snake_case		:      Optional[Any]										=       degree

							def __add__(							self	:  Any   ,     lowerCamelCase	:  Polynomial    )     ->   Polynomial:

														if self.degree > polynomial_a.degree:
																					__snake_case		:      Any										=       self.coefficients[:]
																					for i in range(polynomial_a.degree + 1    ):
																												coefficients[i] += polynomial_a.coefficients[i]
																					return Polynomial(self.degree   ,     lowerCamelCase    )
														else:
																					__snake_case		:      List[str]										=       polynomial_a.coefficients[:]
																					for i in range(self.degree + 1    ):
																												coefficients[i] += self.coefficients[i]
																					return Polynomial(polynomial_a.degree   ,     lowerCamelCase    )

							def __sub__(							self	:  str   ,     lowerCamelCase	:  Polynomial    )     ->   Polynomial:
														return self + polynomial_a * Polynomial(0   ,     [-1]    )

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

							def __mul__(							self	:  Dict   ,     lowerCamelCase	:  Polynomial    )     ->   Polynomial:
														__snake_case		:      list[float]										=       [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   ,     lowerCamelCase    )

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

							def __str__(							self	:  Dict    )     ->   str:
														__snake_case		:      Any										=       ""
														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(lowerCamelCase    )

														return polynomial

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

							def    __snake_case (							self	:  Dict    )     ->   Polynomial:
														__snake_case		:      list[float]										=       [0] * self.degree
														for i in range(self.degree    ):
																					__snake_case		:      List[Any]										=       self.coefficients[i + 1] * (i + 1)
														return Polynomial(self.degree - 1   ,     lowerCamelCase    )

							def    __snake_case (							self	:  int   ,     lowerCamelCase	:  int | float = 0    )     ->   Polynomial:
														__snake_case		:      list[float]										=       [0] * (self.degree + 2)
														__snake_case		:      Optional[Any]										=       constant
														for i in range(self.degree + 1    ):
																					__snake_case		:      List[str]										=       self.coefficients[i] / (i + 1)
														return Polynomial(self.degree + 1   ,     lowerCamelCase    )

							def __eq__(							self	:  Tuple   ,     lowerCamelCase	:  object    )     ->   bool:
														if not isinstance(lowerCamelCase   ,     lowerCamelCase    ):
																					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	:  List[Any]   ,     lowerCamelCase	:  object    )     ->   bool:
														return not self.__eq__(lowerCamelCase    )





from __future__ import annotations

from functools import lru_cache
from math import ceil

_snake_case					:		Tuple      =    100

_snake_case					:		int      =    set(range(3, NUM_PRIMES, 2))
primes.add(2)
_snake_case					:		int

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
			if prime not in primes:
						continue
			primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))







@lru_cache(maxsize=1_0_0     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							if number_to_partition < 0:
														return set()
							elif number_to_partition == 0:
														return {1}

							__snake_case		:      set[int]										=       set()
							__snake_case		:      int
							__snake_case		:      int

							for prime in primes:
														if prime > number_to_partition:
																					continue
														for sub in partition(number_to_partition - prime     ):
																					ret.add(sub * prime     )

							return ret







def     lowerCAmelCase_					( __lowerCamelCase = 5_0_0_0     ):
							for number_to_partition in range(1							,     __lowerCamelCase     ):
														if len(partition(__lowerCamelCase     )     ) > number_unique_partitions:
																					return number_to_partition
							return None


if __name__ == "__main__":
			print(f'''{solution() = }''')

