






def  a__ (__lowercase							:Union[str, Any]   )		-> Optional[Any]:
				return [
				    {
				        0: [1, 2],
				        1: [0, 2],
				        2: [0, 1, 3, 5],
				        3: [2, 4],
				        4: [3],
				        5: [2, 6, 8],
				        6: [5, 7],
				        7: [6, 8],
				        8: [5, 7],
				    },
				    {
				        0: [6],
				        1: [9],
				        2: [4, 5],
				        3: [4],
				        4: [2, 3],
				        5: [2],
				        6: [0, 7],
				        7: [6],
				        8: [],
				        9: [1],
				    },
				    {
				        0: [4],
				        1: [6],
				        2: [],
				        3: [5, 6, 7],
				        4: [0, 6],
				        5: [3, 8, 9],
				        6: [1, 3, 4, 7],
				        7: [3, 6, 8, 9],
				        8: [5, 7],
				        9: [5, 7],
				    },
				    {
				        0: [1, 3],
				        1: [0, 2, 4],
				        2: [1, 3, 4],
				        3: [0, 2, 4],
				        4: [1, 2, 3],
				    },
				][index]



def  a__ (__lowercase							:dict[int, list[int]]   )		-> list[tuple[int, int]]:
				_A	:				Optional[Any]   =      0
				_A	:				Dict   =      len(__lowercase   )  # No of vertices in graph
				_A	:				Union[str, Any]   =      [0] * n
				_A	:				List[Any]   =      [False] * n

				def dfs(__lowercase							:List[str]					,  __lowercase							:Tuple					,  __lowercase							:Any					,  __lowercase							:List[str]   ):
								_A	:				Any   =      True
								_A	:				List[str]   =      id_
								id_ += 1
								for to in graph[at]:
												if to == parent:
																pass
												elif not visited[to]:
																dfs(__lowercase					,  __lowercase					,  __lowercase					,  id_   )
																_A	:				Optional[Any]   =      min(low[at]					,  low[to]   )
																if id_ <= low[to]:
																				bridges.append((at, to) if at < to else (to, at)   )
												else:
																# This edge is a back edge and cannot be a bridge
																_A	:				int   =      min(low[at]					,  low[to]   )

				_A	:				list[tuple[int, int]]   =      []
				for i in range(__lowercase   ):
								if not visited[i]:
												dfs(__lowercase					,  -1					,  __lowercase					,  id_   )
				return bridges


if __name__ == "__main__":
	import doctest

	doctest.testmod()











def  a__ (__lowercase							:int					,  __lowercase							:int   )		-> int:
				return abs(__lowercase   ) if a == 0 else greatest_common_divisor(b % a					,  __lowercase   )



def  a__ (__lowercase							:int					,  __lowercase							:int   )		-> int:
				while y:  # --> when y=0 then loop will terminate and return x as final GCD.
								_A  ,				_A	:				Union[str, Any]   =      y, x % y
				return abs(__lowercase   )



def  a__ ()		-> Optional[Any]:
				try:
								_A	:				Optional[Any]   =      input('''Enter two integers separated by comma (,): '''   ).split(''','''   )
								_A	:				List[Any]   =      int(nums[0]   )
								_A	:				Optional[int]   =      int(nums[1]   )
								print(
								    f"""greatest_common_divisor({num_a}, {num_a}) = """
								    f"""{greatest_common_divisor(__lowercase					,  __lowercase   )}"""   )
								print(f"""By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(__lowercase					,  __lowercase   )}"""   )
				except (IndexError, UnboundLocalError, ValueError):
								print('''Wrong input'''   )


if __name__ == "__main__":
	main()



