






'''simple docstring'''

import unittest

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



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						Optional[Any]      )  ->			None:
			__magic_name__	:   int					     =					Vector([1, 2, 3]      )
			self.assertEqual(x.component(0      )  ,					1      )
			self.assertEqual(x.component(2      )  ,					3      )
			__magic_name__	:   Optional[int]					     =					Vector()







		def        __lowerCAmelCase		( self		:						str      )  ->			None:
			__magic_name__	:   List[str]					     =					Vector([0, 0, 0, 0, 0, 1]      )
			self.assertEqual(str(_A      )  ,					'(0,0,0,0,0,1)'      )







		def        __lowerCAmelCase		( self		:						Dict      )  ->			None:
			__magic_name__	:   List[Any]					     =					Vector([1, 2, 3, 4]      )
			self.assertEqual(len(_A      )  ,					4      )







		def        __lowerCAmelCase		( self		:						Union[str, Any]      )  ->			None:
			__magic_name__	:   Union[str, Any]					     =					Vector([1, 2]      )
			__magic_name__	:   List[str]					     =					Vector([1, 2, 3, 4, 5]      )
			__magic_name__	:   List[str]					     =					Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]      )
			__magic_name__	:   Optional[Any]					     =					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        __lowerCAmelCase		( self		:						Optional[Any]      )  ->			None:
			__magic_name__	:   Any					     =					Vector([1, 2, 3]      )
			__magic_name__	:   Any					     =					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        __lowerCAmelCase		( self		:						Optional[Any]      )  ->			None:
			__magic_name__	:   Any					     =					Vector([1, 2, 3]      )
			__magic_name__	:   Optional[Any]					     =					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        __lowerCAmelCase		( self		:						List[Any]      )  ->			None:
			__magic_name__	:   Union[str, Any]					     =					Vector([1, 2, 3]      )
			__magic_name__	:   Dict					     =					Vector([2, -1, 4]      )  # for test of dot product
			__magic_name__	:   Any					     =					Vector([1, -2, -1]      )
			self.assertEqual(str(x * 3.0      )  ,					'(3.0,6.0,9.0)'      )
			self.assertEqual((a * b)  ,					0      )







		def        __lowerCAmelCase		( self		:						str      )  ->			None:
			self.assertEqual(str(zero_vector(10      )      ).count('0'      )  ,					10      )







		def        __lowerCAmelCase		( self		:						List[Any]      )  ->			None:
			self.assertEqual(str(unit_basis_vector(3  ,					1      )      )  ,					'(0,1,0)'      )







		def        __lowerCAmelCase		( self		:						Union[str, Any]      )  ->			None:
			__magic_name__	:   Any					     =					Vector([1, 2, 3]      )
			__magic_name__	:   str					     =					Vector([1, 0, 1]      )
			self.assertEqual(str(axpy(2  ,					_A  ,					_A      )      )  ,					'(3,4,7)'      )







		def        __lowerCAmelCase		( self		:						Tuple      )  ->			None:
			__magic_name__	:   Tuple					     =					Vector([1, 0, 0, 0, 0, 0]      )
			__magic_name__	:   List[str]					     =					x.copy()
			self.assertEqual(str(_A      )  ,					str(_A      )      )







		def        __lowerCAmelCase		( self		:						Tuple      )  ->			None:
			__magic_name__	:   str					     =					Vector([1, 0, 0]      )
			x.change_component(0  ,					0      )
			x.change_component(1  ,					1      )
			self.assertEqual(str(_A      )  ,					'(0,1,0)'      )







		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			None:
			__magic_name__	:   List[str]					     =					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        __lowerCAmelCase		( self		:						int      )  ->			None:
			__magic_name__	:   Optional[Any]					     =					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,					3  ,					3      )
			__magic_name__	:   Optional[int]					     =					[[-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        __lowerCAmelCase		( self		:						str      )  ->			None:
			__magic_name__	:   Dict					     =					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,					3  ,					3      )
			__magic_name__	:   Any					     =					[[-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        __lowerCAmelCase		( self		:						Dict      )  ->			None:
			__magic_name__	:   int					     =					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,					3  ,					3      )
			self.assertEqual(-5  ,					a.determinant()      )







		def        __lowerCAmelCase		( self		:						List[str]      )  ->			None:
			__magic_name__	:   Any					     =					Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]  ,					3  ,					3      )
			__magic_name__	:   Dict					     =					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        __lowerCAmelCase		( self		:						List[str]      )  ->			None:
			__magic_name__	:   Tuple					     =					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        __lowerCAmelCase		( self		:						Optional[int]      )  ->			None:
			__magic_name__	:   Optional[int]					     =					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,					3  ,					3      )
			self.assertEqual(7  ,					a.component(2  ,					1      )  ,					0.01      )







		def        __lowerCAmelCase		( self		:						Any      )  ->			None:
			__magic_name__	:   Optional[int]					     =					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,					3  ,					3      )
			__magic_name__	:   List[str]					     =					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        __lowerCAmelCase		( self		:						Tuple      )  ->			None:
			__magic_name__	:   Union[str, Any]					     =					Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,					3  ,					3      )
			__magic_name__	:   Dict					     =					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        __lowerCAmelCase		( self		:						Union[str, Any]      )  ->			None:
			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'''

def lowerCamelCase      (      lowerCAmelCase    :     int		):





	"""simple docstring"""







	__magic_name__	:   Optional[int]					     =					1
	for i in range(1		,		num + 1		):
		fact *= i
	return fact





def lowerCamelCase      (      lowerCAmelCase    :     int		):





	"""simple docstring"""







	__magic_name__	:   List[str]					     =					0
	while number > 0:
		__magic_name__	:   str					     =					number % 10
		sum_of_digits += last_digit
		__magic_name__	:   Optional[int]					     =					number // 10  # Removing the last_digit from the given number
	return sum_of_digits





def lowerCamelCase      (      lowerCAmelCase    :     int = 100		):





	"""simple docstring"""







	__magic_name__	:   int					     =					factorial(lowerCAmelCase		)
	__magic_name__	:   Any					     =					split_and_add(lowerCAmelCase		)
	return result


if __name__ == "__main__":
							print(solution(int(input('''Enter the Number: ''').strip())))