



from __future__ import annotations



class      _UpperCAmelCase      :




     def __init__(					self			,    a__):
         A__					=       TypeError(
             '''Matrices must be formed from a list of zero or more lists containing at '''
             '''least one and the same number of values, each of which must be of type '''
             '''int or float.''')
         if len(a__) != 0:
             A__					=       len(rows[0])
             if cols == 0:
                 raise error
             for row in rows:
                 if len(a__) != cols:
                     raise error
                 for value in row:
                     if not isinstance(a__			,    (int, float)):
                         raise error
             A__					=       rows
         else:
             A__					=       []




     def 		snake_case_		(					self):
         return [[row[i] for row in self.rows] for i in range(len(self.rows[0]))]




     @property
     def 		snake_case_		(					self):
         return len(self.rows)




     @property
     def 		snake_case_		(					self):
         return len(self.rows[0])




     @property
     def 		snake_case_		(					self):
         return (self.num_rows, self.num_columns)




     @property
     def 		snake_case_		(					self):
         return self.order[0] == self.order[1]




     def 		snake_case_		(					self):
         A__					=       [
             [0 if column_num != row_num else 1 for column_num in range(self.num_rows)]
             for row_num in range(self.num_rows)
         ]
         return Matrix(a__)




     def 		snake_case_		(					self):
         if not self.is_square:
             return 0
         if self.order == (0, 0):
             return 1
         if self.order == (1, 1):
             return int(self.rows[0][0])
         if self.order == (2, 2):
             return int(
                 (self.rows[0][0] * self.rows[1][1])
                 - (self.rows[0][1] * self.rows[1][0]))
         else:
             return sum(
                 self.rows[0][column] * self.cofactors().rows[0][column]
                 for column in range(self.num_columns))




     def 		snake_case_		(					self):
         return bool(self.determinant())




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       [
             [
                 self.rows[other_row][other_column]
                 for other_column in range(self.num_columns)
                 if other_column != column
             ]
             for other_row in range(self.num_rows)
             if other_row != row
         ]
         return Matrix(a__).determinant()




     def 		snake_case_		(					self			,    a__			,    a__):
         if (row + column) % 2 == 0:
             return self.get_minor(a__			,    a__)
         return -1 * self.get_minor(a__			,    a__)




     def 		snake_case_		(					self):
         return Matrix(
             [
                 [self.get_minor(a__			,    a__) for column in range(self.num_columns)]
                 for row in range(self.num_rows)
             ])




     def 		snake_case_		(					self):
         return Matrix(
             [
                 [
                     self.minors().rows[row][column]
                     if (row + column) % 2 == 0
                     else self.minors().rows[row][column] * -1
                     for column in range(self.minors().num_columns)
                 ]
                 for row in range(self.minors().num_rows)
             ])




     def 		snake_case_		(					self):
         A__					=       [
             [self.cofactors().rows[column][row] for column in range(self.num_columns)]
             for row in range(self.num_rows)
         ]
         return Matrix(a__)




     def 		snake_case_		(					self):
         A__					=       self.determinant()
         if not determinant:
             raise TypeError('''Only matrices with a non-zero determinant have an inverse''')
         return self.adjugate() * (1 / determinant)




     def __repr__(					self):
         return str(self.rows)




     def __str__(					self):
         if self.num_rows == 0:
             return "[]"
         if self.num_rows == 1:
             return "[[" + ". ".join(str(self.rows[0])) + "]]"
         return (
             "["
             + "\n ".join(
                 [
                     '''[''' + '''. '''.join([str(a__) for value in row]) + '''.]'''
                     for row in self.rows
                 ])
             + "]"
         )




     def 		snake_case_		(					self			,    a__			,    a__ = None):
         A__					=       TypeError('''Row must be a list containing all ints and/or floats''')
         if not isinstance(a__			,    a__):
             raise type_error
         for value in row:
             if not isinstance(a__			,    (int, float)):
                 raise type_error
         if len(a__) != self.num_columns:
             raise ValueError(
                 '''Row must be equal in length to the other rows in the matrix''')
         if position is None:
             self.rows.append(a__)
         else:
             A__					=       self.rows[0:position] + [row] + self.rows[position:]




     def 		snake_case_		(					self			,    a__			,    a__ = None):
         A__					=       TypeError(
             '''Column must be a list containing all ints and/or floats''')
         if not isinstance(a__			,    a__):
             raise type_error
         for value in column:
             if not isinstance(a__			,    (int, float)):
                 raise type_error
         if len(a__) != self.num_rows:
             raise ValueError(
                 '''Column must be equal in length to the other columns in the matrix''')
         if position is None:
             A__					=       [self.rows[i] + [column[i]] for i in range(self.num_rows)]
         else:
             A__					=       [
                 self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
                 for i in range(self.num_rows)
             ]




     def __eq__(					self			,    a__):
         if not isinstance(a__			,    a__):
             return NotImplemented
         return self.rows == other.rows




     def __ne__(					self			,    a__):
         return not self == other




     def __neg__(					self):
         return self * -1




     def __add__(					self			,    a__):
         if self.order != other.order:
             raise ValueError('''Addition requires matrices of the same order''')
         return Matrix(
             [
                 [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns)]
                 for i in range(self.num_rows)
             ])




     def __sub__(					self			,    a__):
         if self.order != other.order:
             raise ValueError('''Subtraction requires matrices of the same order''')
         return Matrix(
             [
                 [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns)]
                 for i in range(self.num_rows)
             ])




     def __mul__(					self			,    a__):
         if isinstance(a__			,    (int, float)):
             return Matrix(
                 [[int(element * other) for element in row] for row in self.rows])
         elif isinstance(a__			,    a__):
             if self.num_columns != other.num_rows:
                 raise ValueError(
                     '''The number of columns in the first matrix must '''
                     '''be equal to the number of rows in the second''')
             return Matrix(
                 [
                     [Matrix.dot_product(a__			,    a__) for column in other.columns()]
                     for row in self.rows
                 ])
         else:
             raise TypeError(
                 '''A Matrix can only be multiplied by an int, float, or another matrix''')




     def __pow__(					self			,    a__):
         if not isinstance(a__			,    a__):
             raise TypeError('''A Matrix can only be raised to the power of an int''')
         if not self.is_square:
             raise ValueError('''Only square matrices can be raised to a power''')
         if other == 0:
             return self.identity()
         if other < 0:
             if self.is_invertable():
                 return self.inverse() ** (-other)
             raise ValueError(
                 '''Only invertable matrices can be raised to a negative power''')
         A__					=       self
         for _ in range(other - 1):
             result *= self
         return result




     @classmethod
     def 		snake_case_		(					cls			,    a__			,    a__):
         return sum(row[i] * column[i] for i in range(len(a__)))


if __name__ == "__main__":
   import doctest

   doctest.testmod()





def 		lowerCAmelCase__     (       UpperCamelCase_					:							int						)->	int:
    A__					=       1
    for i in range(1			,							num + 1						):
        fact *= i
    return fact



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int						)->	int:
    A__					=       0
    while number > 0:
        A__					=       number % 1_0
        sum_of_digits += last_digit
        A__					=       number // 1_0  # Removing the last_digit from the given number
    return sum_of_digits



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int = 1_0_0						)->	int:
    A__					=       factorial(UpperCamelCase_						)
    A__					=       split_and_add(UpperCamelCase_						)
    return result


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