


'''simple docstring'''



from math import factorial





class 							__UpperCamelCase    :




	def __init__(       self						,    __a						,    __a							):

						'''simple docstring'''





						__a      :	List[str]    =  real
						if isinstance(__a						,    __a							):
											__a      :	int    =  [1] * rank
						else:
											__a      :	Optional[int]    =  rank




	def __repr__(       self							):

						'''simple docstring'''





						return (
						    f"""{self.real}+"""
						    f"""{"+".join(str(__a							)+"E"+str(n+1							)for n,dual in enumerate(self.duals							)							)}"""
						)




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	List[str]    =  self.duals.copy()
						while cur[-1] == 0:
											cur.pop(-1							)
						return Dual(self.real						,    __a							)




	def __add__(       self						,    __a							):

						'''simple docstring'''





						if not isinstance(__a						,    __a							):
											return Dual(self.real + other						,    self.duals							)
						__a      :	Dict    =  self.duals.copy()
						__a      :	List[Any]    =  other.duals.copy()
						if len(__a							) > len(__a							):
											o_dual.extend([1] * (len(__a							) - len(__a							))							)
						elif len(__a							) < len(__a							):
											s_dual.extend([1] * (len(__a							) - len(__a							))							)
						__a      :	Union[str, Any]    =  []
						for i in range(len(__a							)							):
											new_duals.append(s_dual[i] + o_dual[i]							)
						return Dual(self.real + other.real						,    __a							)

	A_           =   __add__




	def __sub__(       self						,    __a							):

						'''simple docstring'''





						return self + other * -1




	def __mul__(       self						,    __a							):

						'''simple docstring'''





						if not isinstance(__a						,    __a							):
											__a      :	Dict    =  []
											for i in self.duals:
																new_duals.append(i * other							)
											return Dual(self.real * other						,    __a							)
						__a      :	int    =  [0] * (len(self.duals							) + len(other.duals							) + 1)
						for i, item in enumerate(self.duals							):
											for j, jtem in enumerate(other.duals							):
																new_duals[i + j + 1] += item * jtem
						for k in range(len(self.duals							)							):
											new_duals[k] += self.duals[k] * other.real
						for index in range(len(other.duals							)							):
											new_duals[index] += other.duals[index] * self.real
						return Dual(self.real * other.real						,    __a							)

	A_           =   __mul__




	def __truediv__(       self						,    __a							):

						'''simple docstring'''





						if not isinstance(__a						,    __a							):
											__a      :	List[Any]    =  []
											for i in self.duals:
																new_duals.append(i / other							)
											return Dual(self.real / other						,    __a							)
						raise ValueError




	def __floordiv__(       self						,    __a							):

						'''simple docstring'''





						if not isinstance(__a						,    __a							):
											__a      :	List[Any]    =  []
											for i in self.duals:
																new_duals.append(i // other							)
											return Dual(self.real // other						,    __a							)
						raise ValueError





	def __pow__(       self						,    __a							):

						'''simple docstring'''





						if n < 0 or isinstance(__a						,    __a							):
											raise ValueError('power must be a positive integer'							)
						if n == 0:
											return 1
						if n == 1:
											return self
						__a      :	List[str]    =  self
						for _ in range(n - 1							):
											x *= self
						return x






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       Dict						,				_SCREAMING_SNAKE_CASE				:       Optional[int]						,				_SCREAMING_SNAKE_CASE				:       Union[str, Any]       ):
					if not callable(_SCREAMING_SNAKE_CASE       ):
										raise ValueError('differentiate() requires a function as input for func'       )
					if not isinstance(_SCREAMING_SNAKE_CASE						,				(float, int)       ):
										raise ValueError('differentiate() requires a float as input for position'       )
					if not isinstance(_SCREAMING_SNAKE_CASE						,				_SCREAMING_SNAKE_CASE       ):
										raise ValueError('differentiate() requires an int as input for order'       )
					__a      :	str    =  Dual(_SCREAMING_SNAKE_CASE						,				1       )
					__a      :	Any    =  func(_SCREAMING_SNAKE_CASE       )
					if order == 0:
										return result.real
					return result.duals[order - 1] * factorial(_SCREAMING_SNAKE_CASE       )


if __name__ == "__main__":
	import doctest

	doctest.testmod()






	def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       Dict       ):
						return y**2 * y**4




	print(differentiate(f, 9, 2))







'''simple docstring'''



import sys

__lowercase     :						Union[str, Any]	=     (
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       str       ):
					__a      :	List[str]    =  1
					for digit in s:
										product *= int(_SCREAMING_SNAKE_CASE       )
					return product






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       str = N       ):
					__a      :	Optional[int]    =  -sys.maxsize - 1
					__a      :	Optional[Any]    =  n[:13]
					__a      :	int    =  13
					while cur_index < len(_SCREAMING_SNAKE_CASE       ) - 13:
										if int(n[cur_index]       ) >= int(substr[0]       ):
															__a      :	List[Any]    =  substr[1:] + n[cur_index]
															cur_index += 1
										else:
															__a      :	Dict    =  max(_SCREAMING_SNAKE_CASE						,				str_eval(_SCREAMING_SNAKE_CASE       )       )
															__a      :	Optional[Any]    =  n[cur_index : cur_index + 13]
															cur_index += 13
					return largest_product


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



