import mpmath  # for roots of unity
import numpy as np
class   _lowerCAmelCase		:







							def __init__(				self     :    Union[str, Any]	,					__snake_case     :    Optional[Any]=None	,					__snake_case     :    Optional[int]=None		):
										# Input as list
										lowerCamelCase						:Optional[int]						  =     list(poly_a or [0]		)[:]
										lowerCamelCase						:List[str]						  =     list(poly_b or [0]		)[:]

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

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

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

										# The product
										lowerCamelCase						:Dict						  =     self.__multiply()







							def 				snake_case  (				self     :    List[str]	,					__snake_case     :    Tuple		):
										lowerCamelCase						:List[Any]						  =     [[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						:Any						  =     self.c_max_length // 2
										while next_ncol > 0:
													lowerCamelCase						:int						  =     [[] for i in range(_a		)]
													lowerCamelCase						:Any						  =     self.root**next_ncol

													# First half of next step
													lowerCamelCase						:List[str]						  =     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						:Tuple						  =     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						:str						  =     new_dft
													lowerCamelCase						:Optional[int]						  =     next_ncol // 2
										return dft[0]







							def 				snake_case  (				self     :    List[Any]		):
										lowerCamelCase						:List[str]						  =     self.__dft('''A'''		)
										lowerCamelCase						:Optional[int]						  =     self.__dft('''B'''		)
										lowerCamelCase						:List[Any]						  =     [[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						:Optional[int]						  =     2
										while next_ncol <= self.c_max_length:
													lowerCamelCase						:str						  =     [[] for i in range(_a		)]
													lowerCamelCase						:Optional[Any]						  =     self.root ** (next_ncol // 2)
													lowerCamelCase						:Union[str, Any]						  =     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						:Any						  =     new_inverse_c
													next_ncol *= 2
										# Unpack
										lowerCamelCase						:List[Any]						  =     [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		):
										lowerCamelCase						:Optional[Any]						  =     """A = """ + """ + """.join(
										    F"{coef}*x^{i}" for coef, i in enumerate(self.polyA[: self.len_A]		)		)
										lowerCamelCase						:Tuple						  =     """B = """ + """ + """.join(
										    F"{coef}*x^{i}" for coef, i in enumerate(self.polyB[: self.len_B]		)		)
										lowerCamelCase						:Any						  =     """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					(   a_				: int = 4_00_00_00):
			lowerCamelCase						:Dict						  =     [0, 1]
			lowerCamelCase						:Optional[Any]						  =     0
			while fib[i] <= n:
						fib.append(fib[i] + fib[i + 1])
						if fib[i + 2] > n:
									break
						i += 1
			lowerCamelCase						:Dict						  =     0
			for j in range(len(a_) - 1):
						if fib[j] % 2 == 0:
									total += fib[j]

			return total


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



