



'''simple docstring'''






UpperCamelCase__:   int								=			{0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

UpperCamelCase__:   Dict								=			{0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}


def  snake_case_     (					_lowerCAmelCase  :						dict[int, list[int]]   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						list[bool]  )      ->   List[str]:
							UpperCAmelCase :       str 							=		True
							UpperCAmelCase :       Optional[int] 							=		[]

							for neighbour in graph[vert]:
														if not visited[neighbour]:
																					order += topology_sort(__lowerCamelCase   ,      __lowerCamelCase   ,      __lowerCamelCase  )

							order.append(__lowerCamelCase  )

							return order


def  snake_case_     (					_lowerCAmelCase  :						dict[int, list[int]]   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						list[bool]  )      ->   Any:
							UpperCAmelCase :       Tuple 							=		True
							UpperCAmelCase :       Optional[Any] 							=		[vert]

							for neighbour in reversed_graph[vert]:
														if not visited[neighbour]:
																					component += find_components(__lowerCamelCase   ,      __lowerCamelCase   ,      __lowerCamelCase  )

							return component




def  snake_case_     (					_lowerCAmelCase  :						dict[int, list[int]]  )      ->   Optional[Any]:
							UpperCAmelCase :       int 							=		len(__lowerCamelCase  ) * [False]
							UpperCAmelCase :       dict[int, list[int]] 							=		{vert: [] for vert in range(len(__lowerCamelCase  )  )}

							for vert, neighbours in graph.items():
														for neighbour in neighbours:
																					reversed_graph[neighbour].append(__lowerCamelCase  )

							UpperCAmelCase :       Any 							=		[]
							for i, was_visited in enumerate(__lowerCamelCase  ):
														if not was_visited:
																					order += topology_sort(__lowerCamelCase   ,      __lowerCamelCase   ,      __lowerCamelCase  )

							UpperCAmelCase :       Dict 							=		[]
							UpperCAmelCase :       Dict 							=		len(__lowerCamelCase  ) * [False]

							for i in range(len(__lowerCamelCase  )  ):
														UpperCAmelCase :       List[Any] 							=		order[len(__lowerCamelCase  ) - i - 1]
														if not visited[vert]:
																					UpperCAmelCase :       List[Any] 							=		find_components(__lowerCamelCase   ,      __lowerCamelCase   ,      __lowerCamelCase  )
																					components_list.append(__lowerCamelCase  )

							return components_list










"""simple docstring"""






from functools import lru_cache






def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			lowerCamelCase__		:		Optional[Any]			=2
			lowerCamelCase__		:		Optional[int]			=set()
			while i * i <= n:
						if n % i:
									i += 1
						else:
									n //= i
									factors.add(__lowerCamelCase	)
			if n > 1:
						factors.add(__lowerCamelCase	)
			return factors






@lru_cache
def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			return len(unique_prime_factors(__lowerCamelCase	)	)






def      snake_case__   (		__lowerCamelCase				:    list	):
			"""simple docstring"""
			return len(set(__lowerCamelCase	)	) in (0, 1)






def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			lowerCamelCase__		:		Tuple			=2

			while True:
						# Increment each value of a generated range
						lowerCamelCase__		:		Tuple			=[base + i for i in range(__lowerCamelCase	)]

						# Run elements through out unique_prime_factors function
						# Append our target number to the end.
						lowerCamelCase__		:		Optional[Any]			=[upf_len(__lowerCamelCase	) for x in group]
						checker.append(__lowerCamelCase	)

						# If all numbers in the list are equal, return the group variable.
						if equality(__lowerCamelCase	):
									return group

						# Increment our base variable by 1
						base += 1






def      snake_case__   (		__lowerCamelCase				:    int = 4	):
			"""simple docstring"""
			lowerCamelCase__		:		List[Any]			=run(__lowerCamelCase	)
			return results[0] if len(__lowerCamelCase	) else None


if __name__ == "__main__":
		print(solution())




