from math import factorial







def     _a				(      lowercase__  :			int = 1_00 ):







					'''simple docstring'''


					return sum(map(lowercase__     ,  str(factorial(lowercase__ ) ) ) )


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




import heapq as hq
import math
from collections.abc import Iterator

class       snake_case					:




  def __init__(      self     :	str     , a_     :	str				)->       Any:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				List[str]			=		str(id_				)
       SCREAMING_SNAKE_CASE__				:				Any			=		None
       SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		None
       SCREAMING_SNAKE_CASE__				:				Any			=		[]
       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		{}  # {vertex:distance}




  def __lt__(      self     :	int     , a_     :	Tuple				)->       Union[str, Any]:




       """simple docstring"""
       return self.key < other.key




  def __repr__(      self     :	Any				)->       Dict:




       """simple docstring"""
       return self.id




  def 	__lowercase(      self     :	Optional[Any]     , a_     :	int				)->       List[str]:




       """simple docstring"""
       self.neighbors.append(a_				)




  def 	__lowercase(      self     :	int     , a_     :	int     , a_     :	Optional[Any]				)->       Any:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Tuple			=		weight







def     _a				(      lowercase__  :			Optional[Any]     ,  lowercase__  :			Union[str, Any]     ,  lowercase__  :			Tuple     ,  lowercase__  :			Dict ):







     '''simple docstring'''


     graph[a - 1].add_neighbor(graph[b - 1] )
     graph[b - 1].add_neighbor(graph[a - 1] )
     # add the edges:
     graph[a - 1].add_edge(graph[b - 1]     ,  lowercase__ )
     graph[b - 1].add_edge(graph[a - 1]     ,  lowercase__ )







def     _a				(      lowercase__  :			list     ,  lowercase__  :			Vertex ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Any			=		[]
     for u in graph:
          SCREAMING_SNAKE_CASE__				:				Dict			=		math.inf
          SCREAMING_SNAKE_CASE__				:				str			=		None
     SCREAMING_SNAKE_CASE__				:				List[str]			=		0
     SCREAMING_SNAKE_CASE__				:				int			=		graph[:]
     while q:
          SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		min(lowercase__ )
          q.remove(lowercase__ )
          for v in u.neighbors:
               if (v in q) and (u.edges[v.id] < v.key):
                    SCREAMING_SNAKE_CASE__				:				int			=		u
                    SCREAMING_SNAKE_CASE__				:				Any			=		u.edges[v.id]
     for i in range(1     ,  len(lowercase__ ) ):
          a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) )
     return a







def     _a				(      lowercase__  :			list     ,  lowercase__  :			Vertex ):







     '''simple docstring'''


     for u in graph:
          SCREAMING_SNAKE_CASE__				:				List[str]			=		math.inf
          SCREAMING_SNAKE_CASE__				:				int			=		None
     SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		0

     SCREAMING_SNAKE_CASE__				:				Tuple			=		list(lowercase__ )
     hq.heapify(lowercase__ )

     while h:
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		hq.heappop(lowercase__ )
          for v in u.neighbors:
               if (v in h) and (u.edges[v.id] < v.key):
                    SCREAMING_SNAKE_CASE__				:				List[str]			=		u
                    SCREAMING_SNAKE_CASE__				:				Dict			=		u.edges[v.id]
                    hq.heapify(lowercase__ )

     for i in range(1     ,  len(lowercase__ ) ):
          yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1)







def     _a				(      ):







     '''simple docstring'''




if __name__ == "__main__":
      import doctest

      doctest.testmod()



