

'''simple docstring'''





from math import ceil






def 							_lowerCAmelCase (      __magic_name__	:    int = 1001	)							->     int:
						lowercase   :       Any								=1

						for i in range(1      ,   int(ceil(n / 2.0	)	)	):
												lowercase   :       Optional[Any]								=2 * i + 1
												lowercase   :       List[str]								=2 * i
												lowercase   :       Union[str, Any]								=total + 4 * odd**2 - 6 * even

						return total


if __name__ == "__main__":
							import sys

							if len(sys.argv) == 1:
														print(solution())
							else:
														try:
																					UpperCamelCase_      	=					int(sys.argv[1])
																					print(solution(n))
														except ValueError:
																					print("""Invalid entry - please enter a number""")








'''simple docstring'''





import mpmath  # for roots of unity
import numpy as np





class 		__SCREAMING_SNAKE_CASE       :







				def __init__(					self    :		Union[str, Any]		,				UpperCAmelCase__    :		List[Any]=None		,				UpperCAmelCase__    :		Optional[Any]=None      ):
										'''simple docstring'''
										# Input as list
										lowercase   :       Optional[int]								=list(poly_a or [0]      )[:]
										lowercase   :       Optional[Any]								=list(poly_b or [0]      )[:]

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

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

										# Add 0 to make lengths equal a power of 2
										lowercase   :       int								=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
										lowercase   :       Union[str, Any]								=complex(mpmath.root(x=1		,				n=self.c_max_length		,				k=1      )      )

										# The product
										lowercase   :       Tuple								=self.__multiply()







				def    lowerCamelCase_  (					self    :		Union[str, Any]		,				UpperCAmelCase__    :		Tuple      ):
										'''simple docstring'''
										lowercase   :       Union[str, Any]								=[[x] for x in self.polyA] if which == '''A''' else [[x] for x in self.polyB]
										# Corner case
										if len(UpperCAmelCase__      ) <= 1:
																return dft[0]
										#
										lowercase   :       Any								=self.c_max_length // 2
										while next_ncol > 0:
																lowercase   :       Optional[int]								=[[] for i in range(UpperCAmelCase__      )]
																lowercase   :       Tuple								=self.root**next_ncol

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







				def    lowerCamelCase_  (					self    :		List[Any]      ):
										'''simple docstring'''
										lowercase   :       Any								=self.__dft('''A'''      )
										lowercase   :       Any								=self.__dft('''B'''      )
										lowercase   :       Optional[int]								=[[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
										lowercase   :       Optional[int]								=2
										while next_ncol <= self.c_max_length:
																lowercase   :       Optional[int]								=[[] for i in range(UpperCAmelCase__      )]
																lowercase   :       List[str]								=self.root ** (next_ncol // 2)
																lowercase   :       Optional[int]								=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
																lowercase   :       List[Any]								=new_inverse_c
																next_ncol *= 2
										# Unpack
										lowercase   :       Tuple								=[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    :		Any      ):
										'''simple docstring'''
										lowercase   :       Any								='''A = ''' + ''' + '''.join(
										    F'''{coef}*x^{i}''' for coef, i in enumerate(self.polyA[: self.len_A]      )      )
										lowercase   :       Tuple								='''B = ''' + ''' + '''.join(
										    F'''{coef}*x^{i}''' for coef, i in enumerate(self.polyB[: self.len_B]      )      )
										lowercase   :       List[str]								='''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()





