


import mpmath  # for roots of unity
import numpy as np







class        __lowercase       :



		"""simple docstring"""

		def __init__( self		,      A=None		,      A=None	)  -> str:







					'''simple docstring'''







					lowerCamelCase    		=  list(poly_a or [0]	)[:]
					lowerCamelCase    		=  list(poly_b or [0]	)[:]

					# Remove leading zero coefficients
					while self.polyA[-1] == 0:
								self.polyA.pop()
					lowerCamelCase    		=  len(self.polyA	)

					while self.polyB[-1] == 0:
								self.polyB.pop()
					lowerCamelCase    		=  len(self.polyB	)

					# Add 0 to make lengths equal a power of 2
					lowerCamelCase    		=  int(
					    2 ** np.ceil(np.loga(len(self.polyA	) + len(self.polyB	) - 1	)	)	)

					while len(self.polyA	) < self.c_max_length:
								self.polyA.append(0	)
					while len(self.polyB	) < self.c_max_length:
								self.polyB.append(0	)
					# A complex root used for the fourier transform
					lowerCamelCase    		=  complex(mpmath.root(x=1		,      n=self.c_max_length		,      k=1	)	)

					# The product
					lowerCamelCase    		=  self.__multiply()







		def 					__A   ( self		,      A	)  -> Dict:







					'''simple docstring'''







					lowerCamelCase    		=  [[x] for x in self.polyA] if which == """A""" else [[x] for x in self.polyB]
					# Corner case
					if len(A	) <= 1:
								return dft[0]
					#
					lowerCamelCase    		=  self.c_max_length // 2
					while next_ncol > 0:
								lowerCamelCase    		=  [[] for i in range(A	)]
								lowerCamelCase    		=  self.root**next_ncol

								# First half of next step
								lowerCamelCase    		=  1
								for j in range(self.c_max_length // (next_ncol * 2)	):
											for i in range(A	):
														new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j]	)
											current_root *= root
								# Second half of next step
								lowerCamelCase    		=  1
								for j in range(self.c_max_length // (next_ncol * 2)	):
											for i in range(A	):
														new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j]	)
											current_root *= root
								# Update
								lowerCamelCase    		=  new_dft
								lowerCamelCase    		=  next_ncol // 2
					return dft[0]







		def 					__A   ( self	)  -> Optional[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  self.__dft("""A"""	)
					lowerCamelCase    		=  self.__dft("""B"""	)
					lowerCamelCase    		=  [[dft_a[i] * dft_b[i] for i in range(self.c_max_length	)]]
					del dft_a
					del dft_b

					# Corner Case
					if len(inverce_c[0]	) <= 1:
								return inverce_c[0]
					# Inverse DFT
					lowerCamelCase    		=  2
					while next_ncol <= self.c_max_length:
								lowerCamelCase    		=  [[] for i in range(A	)]
								lowerCamelCase    		=  self.root ** (next_ncol // 2)
								lowerCamelCase    		=  1
								# First half of next step
								for j in range(self.c_max_length // next_ncol	):
											for i in range(next_ncol // 2	):
														# Even positions
														new_inverse_c[i].append(
														    (
														        inverce_c[i][j]
														        + inverce_c[i][j + self.c_max_length // next_ncol]
														    )
														    / 2	)
														# Odd positions
														new_inverse_c[i + next_ncol // 2].append(
														    (
														        inverce_c[i][j]
														        - inverce_c[i][j + self.c_max_length // next_ncol]
														    )
														    / (2 * current_root)	)
											current_root *= root
								# Update
								lowerCamelCase    		=  new_inverse_c
								next_ncol *= 2
					# Unpack
					lowerCamelCase    		=  [round(x[0].real		,      8	) + round(x[0].imag		,      8	) * 1J for x in inverce_c]

					# Remove leading 0's
					while inverce_c[-1] == 0:
								inverce_c.pop()
					return inverce_c







		def __str__( self	)  -> Tuple:







					'''simple docstring'''







					lowerCamelCase    		=  """A = """ + """ + """.join(
					    F'{coef}*x^{i}' for coef, i in enumerate(self.polyA[: self.len_A]	)	)
					lowerCamelCase    		=  """B = """ + """ + """.join(
					    F'{coef}*x^{i}' for coef, i in enumerate(self.polyB[: self.len_B]	)	)
					lowerCamelCase    		=  """A*B = """ + """ + """.join(
					    F'{coef}*x^{i}' for coef, i in enumerate(self.product	)	)

					return F'{a}\n{b}\n{c}'


# Unit tests
if __name__ == "__main__":
		import doctest

		doctest.testmod()





def 	__lowerCamelCase						(							lowerCamelCase__		:						int      ):





			'''simple docstring'''




			lowerCamelCase    		=  (1 + 24 * n) ** 0.5
			return ((1 + root) / 6) % 1 == 0






def 	__lowerCamelCase						(							lowerCamelCase__		:						int = 5000      ):





			'''simple docstring'''




			lowerCamelCase    		=  [(i * (3 * i - 1)) // 2 for i in range(1  ,							lowerCamelCase__      )]
			for i, pentagonal_i in enumerate(lowerCamelCase__      ):
						for j in range(lowerCamelCase__  ,							len(lowerCamelCase__      )      ):
									lowerCamelCase    		=  pentagonal_nums[j]
									lowerCamelCase    		=  pentagonal_i + pentagonal_j
									lowerCamelCase    		=  pentagonal_j - pentagonal_i
									if is_pentagonal(lowerCamelCase__      ) and is_pentagonal(lowerCamelCase__      ):
												return b

			return -1


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

