





'''simple docstring'''




import sys

lowercase__       : int         =       (
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)






def 			_lowerCAmelCase     (    __snake_case    :					str     )	->	int:
     __A		:					Dict						=			1
     for digit in s:
          product *= int(__snake_case     )
     return product






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


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







from __future__ import annotations

from collections.abc import MutableSequence





class 					A__     :

     '''simple docstring'''






     def __init__( self      :    Dict   ,						_SCREAMING_SNAKE_CASE      :    int   ,						_SCREAMING_SNAKE_CASE      :    MutableSequence[float] ):






           """simple docstring"""




           if len(_SCREAMING_SNAKE_CASE ) != degree + 1:
                 raise ValueError(
                     'The number of coefficients should be equal to the degree + 1.' )

           UpperCamelCase					       =  list(_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  degree







     def __add__( self      :    Any   ,						_SCREAMING_SNAKE_CASE      :    Polynomial ):






           """simple docstring"""




           if self.degree > polynomial_a.degree:
                 UpperCamelCase					       =  self.coefficients[:]
                 for i in range(polynomial_a.degree + 1 ):
                       coefficients[i] += polynomial_a.coefficients[i]
                 return Polynomial(self.degree   ,						_SCREAMING_SNAKE_CASE )
           else:
                 UpperCamelCase					       =  polynomial_a.coefficients[:]
                 for i in range(self.degree + 1 ):
                       coefficients[i] += self.coefficients[i]
                 return Polynomial(polynomial_a.degree   ,						_SCREAMING_SNAKE_CASE )







     def __sub__( self      :    Optional[int]   ,						_SCREAMING_SNAKE_CASE      :    Polynomial ):






           """simple docstring"""




           return self + polynomial_a * Polynomial(0   ,						[-1] )







     def __neg__( self      :    Any ):






           """simple docstring"""




           return Polynomial(self.degree   ,						[-c for c in self.coefficients] )







     def __mul__( self      :    Union[str, Any]   ,						_SCREAMING_SNAKE_CASE      :    Polynomial ):






           """simple docstring"""




           UpperCamelCase					       =  [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   ,						_SCREAMING_SNAKE_CASE )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int]   ,						_SCREAMING_SNAKE_CASE      :    int | float ):






           """simple docstring"""




           UpperCamelCase					       =  0
           for i in range(self.degree + 1 ):
                 result += self.coefficients[i] * (substitution**i)
           return result







     def __str__( self      :    Union[str, Any] ):






           """simple docstring"""




           UpperCamelCase					       =  ''
           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(_SCREAMING_SNAKE_CASE )

           return polynomial







     def __repr__( self      :    str ):






           """simple docstring"""




           return self.__str__()







     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[Any] ):






           """simple docstring"""




           UpperCamelCase					       =  [0] * self.degree
           for i in range(self.degree ):
                 UpperCamelCase					       =  self.coefficients[i + 1] * (i + 1)
           return Polynomial(self.degree - 1   ,						_SCREAMING_SNAKE_CASE )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int]   ,						_SCREAMING_SNAKE_CASE      :    int | float = 0 ):






           """simple docstring"""




           UpperCamelCase					       =  [0] * (self.degree + 2)
           UpperCamelCase					       =  constant
           for i in range(self.degree + 1 ):
                 UpperCamelCase					       =  self.coefficients[i] / (i + 1)
           return Polynomial(self.degree + 1   ,						_SCREAMING_SNAKE_CASE )







     def __eq__( self      :    Any   ,						_SCREAMING_SNAKE_CASE      :    object ):






           """simple docstring"""




           if not isinstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE ):
                 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      :    str   ,						_SCREAMING_SNAKE_CASE      :    object ):






           """simple docstring"""




           return not self.__eq__(_SCREAMING_SNAKE_CASE )



