






from __future__ import annotations

UpperCAmelCase__				   =		{
    "A": ["B", "C", "E"],
    "B": ["A", "D", "E"],
    "C": ["A", "F", "G"],
    "D": ["B"],
    "E": ["A", "B", "D"],
    "F": ["C"],
    "G": ["C"],
}






class 		lowercase_					:






      '''simple docstring'''




      def __init__(      self      :						Dict ,					__UpperCAmelCase      :						dict[str, list[str]] ,					__UpperCAmelCase      :						str  )    ->None:




       """simple docstring"""


       a		  =      graph
       # mapping node to its parent in resulting breadth first tree
       a		  =      {}
       a		  =      source_vertex







      def       __lowerCAmelCase					(      self      :						Union[str, Any]  )    ->None:




       """simple docstring"""


       a		  =      {self.source_vertex}
       a		  =      None
       a		  =      [self.source_vertex]  # first in first out queue

       while queue:
        a		  =      queue.pop(0  )
        for adjacent_vertex in self.graph[vertex]:
         if adjacent_vertex not in visited:
          visited.add(__UpperCAmelCase  )
          a		  =      vertex
          queue.append(__UpperCAmelCase  )







      def       __lowerCAmelCase					(      self      :						Optional[int] ,					__UpperCAmelCase      :						str  )    ->str:




       """simple docstring"""


       if target_vertex == self.source_vertex:
        return self.source_vertex

       a		  =      self.parent.get(__UpperCAmelCase  )
       if target_vertex_parent is None:
        a		  =      (
            F"""No path from vertex: {self.source_vertex} to vertex: {target_vertex}"""
        )
        raise ValueError(__UpperCAmelCase  )

       return self.shortest_path(__UpperCAmelCase  ) + F"""->{target_vertex}"""


if __name__ == "__main__":
     UpperCAmelCase__				   =		Graph(graph, "G")
     g.breath_first_search()
     print(g.shortest_path("D"))
     print(g.shortest_path("G"))
     print(g.shortest_path("Foo"))






'''simple docstring'''






def 				UpperCamelCase_			(    A__					:   int = 1_00					):
  '''simple docstring'''





  lowerCAmelCase_			:      int			=   set()

  lowerCAmelCase_			:      Tuple			=   0

  lowerCAmelCase_			:      str			=   n + 1  # maximum limit

  for a in range(2							,    A__					):
    for b in range(2							,    A__					):
      lowerCAmelCase_			:      str			=   a**b  # calculates the current power
      collect_powers.add(A__					)  # adds the result to the set
  return len(A__					)


if __name__ == "__main__":
  print("Number of terms ", solution(int(str(input()).strip())))



