





import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)
class     SCREAMING_SNAKE_CASE       (unittest.TestCase				):


   def 	SCREAMING_SNAKE_CASE_							(   self      :    str	)->       int:





     """simple docstring"""







     lowercase__           =  Vector([1, 2, 3]	)
     self.assertEqual(x.component(0	)      ,					1	)
     self.assertEqual(x.component(2	)      ,					3	)
     lowercase__           =  Vector()


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Dict	)->       int:





     """simple docstring"""







     lowercase__           =  Vector([0, 0, 0, 0, 0, 1]	)
     self.assertEqual(str(_A	)      ,					'(0,0,0,0,0,1)'	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[int]	)->       Union[str, Any]:





     """simple docstring"""







     lowercase__           =  Vector([1, 2, 3, 4]	)
     self.assertEqual(len(_A	)      ,					4	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]	)->       Union[str, Any]:





     """simple docstring"""







     lowercase__           =  Vector([1, 2]	)
     lowercase__           =  Vector([1, 2, 3, 4, 5]	)
     lowercase__           =  Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]	)
     lowercase__           =  Vector([1, -1, 1, -1, 2, -3, 4, -5]	)
     self.assertAlmostEqual(x.euclidean_length()      ,					2.236      ,					3	)
     self.assertAlmostEqual(y.euclidean_length()      ,					7.416      ,					3	)
     self.assertEqual(z.euclidean_length()      ,					0	)
     self.assertAlmostEqual(w.euclidean_length()      ,					7.616      ,					3	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Tuple	)->       Union[str, Any]:





     """simple docstring"""







     lowercase__           =  Vector([1, 2, 3]	)
     lowercase__           =  Vector([1, 1, 1]	)
     self.assertEqual((x + y).component(0	)      ,					2	)
     self.assertEqual((x + y).component(1	)      ,					3	)
     self.assertEqual((x + y).component(2	)      ,					4	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[Any]	)->       str:





     """simple docstring"""







     lowercase__           =  Vector([1, 2, 3]	)
     lowercase__           =  Vector([1, 1, 1]	)
     self.assertEqual((x - y).component(0	)      ,					0	)
     self.assertEqual((x - y).component(1	)      ,					1	)
     self.assertEqual((x - y).component(2	)      ,					2	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]	)->       Optional[Any]:





     """simple docstring"""







     lowercase__           =  Vector([1, 2, 3]	)
     lowercase__           =  Vector([2, -1, 4]	)  # for test of dot product
     lowercase__           =  Vector([1, -2, -1]	)
     self.assertEqual(str(x * 3.0	)      ,					'(3.0,6.0,9.0)'	)
     self.assertEqual((a * b)      ,					0	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]	)->       List[Any]:





     """simple docstring"""







     self.assertEqual(str(zero_vector(10	)	).count('0'	)      ,					10	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    int	)->       Optional[Any]:





     """simple docstring"""







     self.assertEqual(str(unit_basis_vector(3      ,					1	)	)      ,					'(0,1,0)'	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]	)->       str:





     """simple docstring"""







     lowercase__           =  Vector([1, 2, 3]	)
     lowercase__           =  Vector([1, 0, 1]	)
     self.assertEqual(str(axpy(2      ,					_A      ,					_A	)	)      ,					'(3,4,7)'	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]	)->       Optional[Any]:





     """simple docstring"""







     lowercase__           =  Vector([1, 0, 0, 0, 0, 0]	)
     lowercase__           =  x.copy()
     self.assertEqual(str(_A	)      ,					str(_A	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[Any]	)->       str:





     """simple docstring"""







     lowercase__           =  Vector([1, 0, 0]	)
     x.change_component(0      ,					0	)
     x.change_component(1      ,					1	)
     self.assertEqual(str(_A	)      ,					'(0,1,0)'	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]	)->       Optional[Any]:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     self.assertEqual('|1,2,3|\n|2,4,5|\n|6,7,8|\n'      ,					str(_A	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[Any]	)->       int:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     lowercase__           =  [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
     for x in range(a.height()	):
       for y in range(a.width()	):
         self.assertEqual(minors[x][y]      ,					a.minor(_A      ,					_A	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Any	)->       int:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     lowercase__           =  [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
     for x in range(a.height()	):
       for y in range(a.width()	):
         self.assertEqual(cofactors[x][y]      ,					a.cofactor(_A      ,					_A	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Any	)->       Any:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     self.assertEqual(-5      ,					a.determinant()	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[int]	)->       List[str]:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]      ,					3      ,					3	)
     lowercase__           =  Vector([1, 2, 3]	)
     self.assertEqual('(14,32,50)'      ,					str(a * x	)	)
     self.assertEqual('|2,4,6|\n|8,10,12|\n|14,16,18|\n'      ,					str(a * 2	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[Any]	)->       Union[str, Any]:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     a.change_component(0      ,					2      ,					5	)
     self.assertEqual('|1,2,5|\n|2,4,5|\n|6,7,8|\n'      ,					str(_A	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]	)->       Union[str, Any]:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     self.assertEqual(7      ,					a.component(2      ,					1	)      ,					0.01	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Union[str, Any]	)->       Optional[Any]:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     lowercase__           =  Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]      ,					3      ,					3	)
     self.assertEqual('|2,4,10|\n|4,8,10|\n|12,14,18|\n'      ,					str(a + b	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Dict	)->       List[Any]:





     """simple docstring"""







     lowercase__           =  Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]      ,					3      ,					3	)
     lowercase__           =  Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]      ,					3      ,					3	)
     self.assertEqual('|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'      ,					str(a - b	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    str	)->       List[str]:





     """simple docstring"""







     self.assertEqual(
         '|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n'      ,					str(square_zero_matrix(5	)	)      ,					)


if __name__ == "__main__":
      unittest.main()









import sys

lowercase_          =		(
    """73167176531330624919225119674426574742355349194934"""
    """96983520312774506326239578318016984801869478851843"""
    """85861560789112949495459501737958331952853208805511"""
    """12540698747158523863050715693290963295227443043557"""
    """66896648950445244523161731856403098711121722383113"""
    """62229893423380308135336276614282806444486645238749"""
    """30358907296290491560440772390713810515859307960866"""
    """70172427121883998797908792274921901699720888093776"""
    """65727333001053367881220235421809751254540594752243"""
    """52584907711670556013604839586446706324415722155397"""
    """53697817977846174064955149290862569321978468622482"""
    """83972241375657056057490261407972968652414535100474"""
    """82166370484403199890008895243450658541227588666881"""
    """16427171479924442928230863465674813919123162824586"""
    """17866458359124566529476545682848912883142607690042"""
    """24219022671055626321111109370544217506941658960408"""
    """07198403850962455444362981230987879927244284909188"""
    """84580156166097919133875499200524063689912560717606"""
    """05886116467109405077541002256983155200055935729725"""
    """71636269561882670428252483600823257530420752963450"""
)




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE = N		)    ->       int:
  lowercase__           =  -sys.maxsize - 1
  for i in range(len(_SCREAMING_SNAKE_CASE		) - 12		):
    lowercase__           =  1
    for j in range(13		):
      product *= int(n[i + j]		)
    if product > largest_product:
      lowercase__           =  product
  return largest_product


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


