code: 
  
  from __future__ import annotations
  
  from queue import Queue
  
  
  
  
  
  
  class    __A				:
  
  
  
  
  
  
      def __init__(	self			:    Optional[Any]    ):
          lowerCAmelCase				:			dict[int, list[int]]    			=      {}
  
  
  
  
  
  
      def 	lowercase__ (	self			:    int    ):
          for i in self.vertices:
              print(UpperCAmelCase_    ,				' : '    ,				' -> '.join([str(UpperCAmelCase_    ) for j in self.vertices[i]]    )    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    List[str]    ,				UpperCAmelCase_			:    int    ,				UpperCAmelCase_			:    int    ):
          if from_vertex in self.vertices:
              self.vertices[from_vertex].append(UpperCAmelCase_    )
          else:
              lowerCAmelCase				:			Union[str, Any]    			=      [to_vertex]
  
  
  
  
  
  
      def 	lowercase__ (	self			:    List[Any]    ,				UpperCAmelCase_			:    int    ):
          lowerCAmelCase				:			Optional[Any]    			=      set()
  
          # create a first in first out queue to store all the vertices for BFS
          lowerCAmelCase				:			Queue    			=      Queue()
  
          # mark the source node as visited and enqueue it
          visited.add(UpperCAmelCase_    )
          queue.put(UpperCAmelCase_    )
  
          while not queue.empty():
              lowerCAmelCase				:			int    			=      queue.get()
  
              # loop through all adjacent vertex and enqueue it if not yet visited
              for adjacent_vertex in self.vertices[vertex]:
                  if adjacent_vertex not in visited:
                      queue.put(UpperCAmelCase_    )
                      visited.add(UpperCAmelCase_    )
          return visited
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod(verbose=True)
  
   __A   :     Union[str, Any]      =			Graph()
   g.add_edge(0, 1)
   g.add_edge(0, 2)
   g.add_edge(1, 2)
   g.add_edge(2, 0)
   g.add_edge(2, 3)
   g.add_edge(3, 3)
  
   g.print_graph()
   # 0  :  1 -> 2
   # 1  :  2
   # 2  :  0 -> 3
   # 3  :  3
  
   assert sorted(g.bfs(2)) == [0, 1, 2, 3]
  
  
  
  
  
  
style_context: 
  
  from __future__ import annotations
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> set[int]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			List[str]    			=      {1}
      lowerCAmelCase				:			int    			=      [1]
      for _ in range(2,      depth + 1				):
          lowerCAmelCase				:			str    			=      [*previous_coefficients, 0]
          lowerCAmelCase				:			Optional[int]    			=      [0, *previous_coefficients]
          lowerCAmelCase				:			Tuple    			=      []
          for x, y in zip(_UpperCAmelCase,      _UpperCAmelCase				):
              coefficients.add(x + y				)
              previous_coefficients.append(x + y				)
      return coefficients
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> set[int]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			str    			=      set()
      for number in unique_coefficients:
          lowerCAmelCase				:			Dict    			=      2
          lowerCAmelCase				:			Tuple    			=      number
          while divisor**2 <= copy_number:
              lowerCAmelCase				:			List[str]    			=      0
              while copy_number % divisor == 0:
                  copy_number //= divisor
                  multiplicity += 1
              if multiplicity >= 2:
                  non_squarefrees.add(_UpperCAmelCase				)
                  break
              divisor += 1
  
      return unique_coefficients.difference(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase = 51				)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			int    			=      get_pascal_triangle_unique_coefficients(_UpperCAmelCase				)
      lowerCAmelCase				:			Optional[int]    			=      get_squarefrees(_UpperCAmelCase				)
      return sum(_UpperCAmelCase				)
  
  
  if __name__ == "__main__":
   print(F'{solution() = }')
  
  
  
  
  
  