






from __future__ import annotations

from queue import Queue





class   SCREAMING_SNAKE_CASE :





							"""simple docstring"""

							def __init__(     self:      Union[str, Any]      )			-> None:
												_A									=       {}

							def 					__A       (     self:      Any      )			-> None:
												for i in self.vertices:
																	print(__A						,   ''' : '''						,   ''' -> '''.join([str(__A      ) for j in self.vertices[i]]      )      )

							def 					__A       (     self:      Optional[int]						,   __A:      int						,   __A:      int      )			-> None:
												if from_vertex in self.vertices:
																	self.vertices[from_vertex].append(__A      )
												else:
																	_A									=       [to_vertex]



							def 					__A       (     self:      Any						,   __A:      int      )			-> set[int]:
												_A									=       set()

												# create a first in first out queue to store all the vertices for BFS
												_A									=       Queue()

												# mark the source node as visited and enqueue it
												visited.add(__A      )
												queue.put(__A      )

												while not queue.empty():
																	_A									=       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(__A      )
																											visited.add(__A      )
												return visited


if __name__ == "__main__":
				from doctest import testmod

				testmod(verbose=True)

				__A          = 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]







'''simple docstring'''







import sys

sys.set_int_max_str_digits(0)  # type: ignore






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Optional[Any]      =					[0] * 11
       _A     :	str      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	int      =					1
              _A     :	Optional[int]      =					number // 10
       # flag
       _A     :	List[Any]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	Optional[int]      =					False
       if not f:
              return f

       # mark first 9 numbers
       _A     :	Optional[int]      =					int(str(lowerCamelCase   )[:9]   )

       for _ in range(9   ):
              _A     :	Optional[Any]      =					1
              _A     :	str      =					number // 10

       # check first 9 numbers for pandigitality

       for x in range(9   ):
              if not check_front[x + 1]:
                     _A     :	Optional[Any]      =					False
       return f






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Dict      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	List[str]      =					1
              _A     :	Dict      =					number // 10
       # flag
       _A     :	Optional[int]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	List[str]      =					False
       return f






def       lowerCAmelCase__       (				):
       _A     :	List[Any]      =					1
       _A     :	Dict      =					1
       _A     :	Dict      =					2
       # temporary Fibonacci numbers

       _A     :	List[Any]      =					1
       _A     :	Union[str, Any]      =					1
       _A     :	List[Any]      =					2
       # temporary Fibonacci numbers mod 1e9

       # mod m=1e9, done for fast optimisation
       _A     :	Tuple      =					[0] * 1000000
       _A     :	Any      =					1000000000

       for x in range(1000000   ):
              _A     :	Tuple      =					(aa + ba) % m
              _A     :	Optional[Any]      =					ba % m
              _A     :	str      =					ca % m
              if checka(lowerCamelCase   ):
                     _A     :	Dict      =					1

       for x in range(1000000   ):
              _A     :	List[str]      =					a + b
              _A     :	Optional[int]      =					b
              _A     :	str      =					c
              # perform check only if in tocheck
              if tocheck[x + 3] and check(lowerCamelCase   ):
                     return x + 3  # first 2 already done
       return -1


if __name__ == "__main__":
   print(f"""{solution() = }""")






