




"""simple docstring"""


def 					UpperCAmelCase__       (snake_case__							:					int		,   snake_case__							:					int    ):
  """simple docstring"""

  while b:
    _snake_case		,					_snake_case							:		Optional[int]								=  b, a % b
  return a


def 					UpperCAmelCase__       (snake_case__							:					int		,   snake_case__							:					int    ):
  """simple docstring"""

  return a if b == 0 else euclidean_gcd_recursive(snake_case__		,   a % b    )


def 					UpperCAmelCase__       ():
  """simple docstring"""

  print(F"euclidean_gcd(3, 5) = {euclidean_gcd(3		,   5    )}"    )
  print(F"euclidean_gcd(5, 3) = {euclidean_gcd(5		,   3    )}"    )
  print(F"euclidean_gcd(1, 3) = {euclidean_gcd(1		,   3    )}"    )
  print(F"euclidean_gcd(3, 6) = {euclidean_gcd(3		,   6    )}"    )
  print(F"euclidean_gcd(6, 3) = {euclidean_gcd(6		,   3    )}"    )

  print(F"euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3		,   5    )}"    )
  print(F"euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5		,   3    )}"    )
  print(F"euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1		,   3    )}"    )
  print(F"euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3		,   6    )}"    )
  print(F"euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6		,   3    )}"    )


if __name__ == "__main__":
     main()



'''simple docstring'''




_lowercase						: str						=						tuple[float, float, float]
_lowercase						: List[Any]						=						tuple[float, float, float]




def 							lowerCamelCase	(      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad )			->      Vectorad:
							lowercase_					:			List[str]										=       end_pointa[0] - end_pointa[0]
							lowercase_					:			Union[str, Any]										=       end_pointa[1] - end_pointa[1]
							lowercase_					:			List[Any]										=       end_pointa[2] - end_pointa[2]
							return (x, y, z)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Vectorad      ,      UpperCAmelCase__       :					Vectorad )			->      Vectorad:
							lowercase_					:			List[Any]										=       ab[1] * ac[2] - ab[2] * ac[1]  # *i
							lowercase_					:			Union[str, Any]										=       (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
							lowercase_					:			List[str]										=       ab[0] * ac[1] - ab[1] * ac[0]  # *k
							return (x, y, z)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Vectorad      ,      UpperCAmelCase__       :					int )			->      bool:
							return tuple(round(UpperCAmelCase__      ,      UpperCAmelCase__ ) for x in vector ) == (0, 0, 0)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					int = 10 )			->      bool:
							lowercase_					:			Dict										=       create_vector(UpperCAmelCase__      ,      UpperCAmelCase__ )
							lowercase_					:			Optional[int]										=       create_vector(UpperCAmelCase__      ,      UpperCAmelCase__ )
							return is_zero_vector(get_ad_vectors_cross(UpperCAmelCase__      ,      UpperCAmelCase__ )      ,      UpperCAmelCase__ )





