






import unittest

import numpy as np







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase = None ,   )			->     np.ndarray:
     UpperCamelCase__      :       Any	    =  np.shape(__UpperCAmelCase      )
     UpperCamelCase__      :       int	    =  np.shape(__UpperCAmelCase      )
     UpperCamelCase__      :       List[str]	    =  np.shape(__UpperCAmelCase      )

     if shape_a[0] != shape_b[0]:
          UpperCamelCase__      :       Dict	    =  (
              "Expected the same number of rows for A and B. "
              f'Instead found A of size {shape_a} and B of size {shape_b}'
          )
          raise ValueError(__UpperCAmelCase      )

     if shape_b[1] != shape_c[1]:
          UpperCamelCase__      :       Optional[int]	    =  (
              "Expected the same number of columns for B and C. "
              f'Instead found B of size {shape_b} and C of size {shape_c}'
          )
          raise ValueError(__UpperCAmelCase      )

     UpperCamelCase__      :       Any	    =  pseudo_inv
     if a_inv is None:
          try:
               UpperCamelCase__      :       Optional[int]	    =  np.linalg.inv(__UpperCAmelCase      )
          except np.linalg.LinAlgError:
               raise ValueError(
                   "Input matrix A is not invertible. Cannot compute Schur complement."      )

     return mat_c - mat_b.T @ a_inv @ mat_b





class       __a  (   unittest.TestCase	):







 def  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      UpperCamelCase__      :       Optional[int]	    =  np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]						)
      UpperCamelCase__      :       List[str]	    =  np.array([[0, 3], [3, 0], [2, 3]]						)
      UpperCamelCase__      :       Tuple	    =  np.array([[2, 1], [6, 3]]						)

      UpperCamelCase__      :       str	    =  schur_complement(lowercase_							,       lowercase_							,       lowercase_						)

      UpperCamelCase__      :       Optional[int]	    =  np.block([[a, b], [b.T, c]]						)

      UpperCamelCase__      :       Union[str, Any]	    =  np.linalg.det(lowercase_						)
      UpperCamelCase__      :       List[Any]	    =  np.linalg.det(lowercase_						)
      UpperCamelCase__      :       Optional[Any]	    =  np.linalg.det(lowercase_						)

      self.assertAlmostEqual(lowercase_							,       det_a * det_s						)







 def  __lowercase (		self :       Optional[int]						):


      '''simple docstring'''






      UpperCamelCase__      :       Optional[Any]	    =  np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]						)
      UpperCamelCase__      :       List[str]	    =  np.array([[0, 3], [3, 0], [2, 3]]						)
      UpperCamelCase__      :       Any	    =  np.array([[2, 1], [6, 3]]						)

      with self.assertRaises(lowercase_						):
           schur_complement(lowercase_							,       lowercase_							,       lowercase_						)







 def  __lowercase (		self :       List[str]						):


      '''simple docstring'''






      UpperCamelCase__      :       Tuple	    =  np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]						)
      UpperCamelCase__      :       Optional[int]	    =  np.array([[0, 3], [3, 0], [2, 3]]						)
      UpperCamelCase__      :       Optional[int]	    =  np.array([[2, 1, 3], [6, 3, 5]]						)

      with self.assertRaises(lowercase_						):
           schur_complement(lowercase_							,       lowercase_							,       lowercase_						)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 unittest.main()







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     int:
     UpperCamelCase__      :       int	    =  1
     for i in range(1 ,   num + 1      ):
          fact *= i
     return fact







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     int:
     UpperCamelCase__      :       List[Any]	    =  0
     while number > 0:
          UpperCamelCase__      :       List[Any]	    =  number % 10
          sum_of_digits += last_digit
          UpperCamelCase__      :       int	    =  number // 10  # Removing the last_digit from the given number
     return sum_of_digits







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase = 100      )			->     int:
     UpperCamelCase__      :       Optional[Any]	    =  factorial(__lowerCAmelCase      )
     UpperCamelCase__      :       Optional[int]	    =  split_and_add(__lowerCAmelCase      )
     return result


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