



def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Optional[Any]				,     _SCREAMING_SNAKE_CASE       :			Tuple    ):
				"""simple docstring"""







				return abs(__A    ) if a == 0 else greatest_common_divisor(b % a				,     __A    )

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			int				,     _SCREAMING_SNAKE_CASE       :			List[str]    ):
				"""simple docstring"""







				while y:  # --> when y=0 then loop will terminate and return x as final GCD.
								__a     ,					__a       =		y, x % y
				return abs(__A    )

def   lowerCAmelCase__						(							):
				"""simple docstring"""







				try:
								__a       =		input("""Enter two integers separated by comma (,): """    ).split(""","""    )
								__a       =		int(nums[0]    )
								__a       =		int(nums[1]    )
								print(
								    f"greatest_common_divisor({num_a}, {num_a}) = "
								    f"{greatest_common_divisor(__A				,     __A    )}"    )
								print(f"By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(__A				,     __A    )}"    )
				except (IndexError, UnboundLocalError, ValueError):
								print("""Wrong input"""    )


if __name__ == "__main__":
						main()





from __future__ import annotations

from collections import Counter
from random import random






class    SCREAMING_SNAKE_CASE			:





							def __init__(   self		:		Optional[Any]	):

											'''simple docstring'''
											__a       =		{}





							def 						UpperCamelCase_					(   self		:		Dict      ,				__lowercase		:		str	):

											'''simple docstring'''
											__a       =		{}





							def 						UpperCamelCase_					(   self		:		List[str]      ,				__lowercase		:		str      ,				__lowercase		:		str      ,				__lowercase		:		float	):

											'''simple docstring'''
											if nodea not in self.connections:
															self.add_node(__lowercase	)
											if nodea not in self.connections:
															self.add_node(__lowercase	)
											__a       =		probability





							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											return list(self.connections	)







							def 						UpperCamelCase_					(   self		:		Tuple      ,				__lowercase		:		str	):

											'''simple docstring'''
											__a       =		0
											__a       =		random()

											for dest in self.connections[node]:
															current_probability += self.connections[node][dest]
															if current_probability > random_value:
																			return dest
											return ""



def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str				,     _SCREAMING_SNAKE_CASE       :			list[tuple[str, str, float]]				,     _SCREAMING_SNAKE_CASE       :			int    ):
				"""simple docstring"""







				__a       =		MarkovChainGraphUndirectedUnweighted()

				for nodea, nodea, probability in transitions:
								graph.add_transition_probability(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )

				__a       =		Counter(graph.get_nodes()    )
				__a       =		start

				for _ in range(_SCREAMING_SNAKE_CASE    ):
								__a       =		graph.transition(_SCREAMING_SNAKE_CASE    )
								visited[node] += 1

				return visited


if __name__ == "__main__":
						import doctest

						doctest.testmod()
