




class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	def __init__(  self     :   Any     ):


				'''simple docstring'''


				_snake_case          =      {}



	def 			A							(  self     :   List[Any]     ):


				'''simple docstring'''


				print(self.vertex     )
				for i in self.vertex:
							print(_snake_case      ,  ' -> '      ,  ' -> '.join([str(_snake_case     ) for j in self.vertex[i]]     )     )



	def 			A							(  self     :   Tuple      ,  lowercase     :   Tuple      ,  lowercase     :   List[str]     ):


				'''simple docstring'''


				if from_vertex in self.vertex:
							self.vertex[from_vertex].append(_snake_case     )
				else:
							# else make a new vertex
							_snake_case          =      [to_vertex]



	def 			A							(  self     :   int     ):


				'''simple docstring'''


				_snake_case          =      [False] * len(self.vertex     )

				# call the recursive helper function
				for i in range(len(self.vertex     )     ):
							if not visited[i]:
										self.dfs_recursive(_snake_case      ,  _snake_case     )





	def 			A							(  self     :   str      ,  lowercase     :   int      ,  lowercase     :   str     ):


				'''simple docstring'''


				_snake_case          =      True

				print(_snake_case      ,  end=' '     )

				# Recur for all the vertices that are adjacent to this node
				for i in self.vertex:
							if not visited[i]:
										self.dfs_recursive(_snake_case      ,  _snake_case     )


if __name__ == "__main__":
			_lowerCamelCase	:    List[str]          =      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()
			print('''DFS:''')
			g.dfs()

			# OUTPUT:
			# 0  ->  1 -> 2
			# 1  ->  2
			# 2  ->  0 -> 3
			# 3  ->  3
			# DFS:
			#  0 1 2 3

def 	a_		(	__lowercase       :     int = 50_000_000			)			->  int:
			_snake_case          =      set()
			_snake_case          =      int((limit - 24) ** (1 / 2)			)

			_snake_case          =      set(range(3	, prime_square_limit + 1	, 2			)			)
			primes.add(2			)
			for p in range(3	, prime_square_limit + 1	, 2			):
						if p not in primes:
									continue
						primes.difference_update(set(range(p * p	, prime_square_limit + 1	, __lowercase			)			)			)

			for primea in primes:
						_snake_case          =      primea * primea
						for primea in primes:
									_snake_case          =      primea * primea * primea
									if square + cube >= limit - 16:
												break
									for primea in primes:
												_snake_case          =      primea * primea * primea * primea
												_snake_case          =      square + cube + tetr
												if total >= limit:
															break
												ret.add(__lowercase			)

			return len(__lowercase			)


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