






'''simple docstring'''






__A    	=   {0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

__A    	=   {0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}




def        _SCREAMING_SNAKE_CASE  (				A  :       dict[int, list[int]]  ,		A  :       int  ,		A  :       list[bool]  )    -> list[int]:







   """simple docstring"""
   __snake_case				:      Any     							= True
   __snake_case				:      Dict     							= []

   for neighbour in graph[vert]:
      if not visited[neighbour]:
         order += topology_sort(A  ,		A  ,		A  )

   order.append(A  )

   return order




def        _SCREAMING_SNAKE_CASE  (				A  :       dict[int, list[int]]  ,		A  :       int  ,		A  :       list[bool]  )    -> list[int]:







   """simple docstring"""
   __snake_case				:      List[str]     							= True
   __snake_case				:      Union[str, Any]     							= [vert]

   for neighbour in reversed_graph[vert]:
      if not visited[neighbour]:
         component += find_components(A  ,		A  ,		A  )

   return component





def        _SCREAMING_SNAKE_CASE  (				A  :       dict[int, list[int]]  )    -> list[list[int]]:







   """simple docstring"""
   __snake_case				:      str     							= len(A  ) * [False]
   __snake_case				:      dict[int, list[int]]     							= {vert: [] for vert in range(len(A  )  )}

   for vert, neighbours in graph.items():
      for neighbour in neighbours:
         reversed_graph[neighbour].append(A  )

   __snake_case				:      Dict     							= []
   for i, was_visited in enumerate(A  ):
      if not was_visited:
         order += topology_sort(A  ,		A  ,		A  )

   __snake_case				:      Tuple     							= []
   __snake_case				:      List[Any]     							= len(A  ) * [False]

   for i in range(len(A  )  ):
      __snake_case				:      Dict     							= order[len(A  ) - i - 1]
      if not visited[vert]:
         __snake_case				:      Optional[int]     							= find_components(A  ,		A  ,		A  )
         components_list.append(A  )

   return components_list







'''simple docstring'''






def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> int:







   """simple docstring"""
   __snake_case				:      str     							= 1
   for i in range(1  ,		num + 1  ):
      fact *= i
   return fact




def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> int:







   """simple docstring"""
   __snake_case				:      Union[str, Any]     							= 0
   while number > 0:
      __snake_case				:      Dict     							= number % 10
      sum_of_digits += last_digit
      __snake_case				:      Union[str, Any]     							= number // 10  # Removing the last_digit from the given number
   return sum_of_digits




def        _SCREAMING_SNAKE_CASE  (				A  :       int = 1_00  )    -> int:







   """simple docstring"""
   __snake_case				:      List[Any]     							= factorial(A  )
   __snake_case				:      Dict     							= split_and_add(A  )
   return result


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