


'''simple docstring'''

import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)





class   snake_case					(					unittest.TestCase    ):





  """simple docstring"""




  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 2, 3]  )
   self.assertEqual(x.component(0  )    ,						1  )
   self.assertEqual(x.component(2  )    ,						3  )
   lowerCamelCase_  				=						Vector()






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([0, 0, 0, 0, 0, 1]  )
   self.assertEqual(str(UpperCamelCase  )    ,						"(0,0,0,0,0,1)"  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 2, 3, 4]  )
   self.assertEqual(len(UpperCamelCase  )    ,						4  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 2]  )
   lowerCamelCase_  				=						Vector([1, 2, 3, 4, 5]  )
   lowerCamelCase_  				=						Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]  )
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 2, 3]  )
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 2, 3]  )
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







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






  def 						snake_case	(					self  ):







   """simple docstring"""
   self.assertEqual(str(zero_vector(10  )  ).count("0"  )    ,						10  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   self.assertEqual(str(unit_basis_vector(3    ,						1  )  )    ,						"(0,1,0)"  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 2, 3]  )
   lowerCamelCase_  				=						Vector([1, 0, 1]  )
   self.assertEqual(str(axpy(2    ,						UpperCamelCase    ,						UpperCamelCase  )  )    ,						"(3,4,7)"  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 0, 0, 0, 0, 0]  )
   lowerCamelCase_  				=						x.copy()
   self.assertEqual(str(UpperCamelCase  )    ,						str(UpperCamelCase  )  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Vector([1, 0, 0]  )
   x.change_component(0    ,						0  )
   x.change_component(1    ,						1  )
   self.assertEqual(str(UpperCamelCase  )    ,						"(0,1,0)"  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						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(UpperCamelCase  )  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]    ,						3    ,						3  )
   lowerCamelCase_  				=						[[-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(UpperCamelCase    ,						UpperCamelCase  )  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]    ,						3    ,						3  )
   lowerCamelCase_  				=						[[-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(UpperCamelCase    ,						UpperCamelCase  )  )






  def 						snake_case	(					self  ):







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






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]    ,						3    ,						3  )
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						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(UpperCamelCase  )  )






  def 						snake_case	(					self  ):







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






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]    ,						3    ,						3  )
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]    ,						3    ,						3  )
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """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()







'''simple docstring'''

from collections.abc import Sequence





def __snake_case      (   UpperCAmelCase_		:		Sequence[int] | None = None	):
 if nums is None or not nums:
  raise ValueError("Input sequence should not be empty"	)

 lowerCamelCase_  				=						nums[0]
 for i in range(1      ,       len(UpperCAmelCase_	)	):
  lowerCamelCase_  				=						nums[i]
  lowerCamelCase_  				=						max(UpperCAmelCase_      ,       ans + num      ,       UpperCAmelCase_	)

 return ans


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # Try on a sample input from the user
     a_						:       Any      			=				int(input("""Enter number of elements : """).strip())
     a_						:       Union[str, Any]      			=				list(map(int, input("""\nEnter the numbers : """).strip().split()))[:n]
     print(max_subsequence_sum(array))



