

import unittest
from timeit import timeit




def        __UpperCamelCase     (      _A					:							int      ,  _A					:							int		)				->int:



							"""simple docstring"""
							lowerCamelCase_								=first_num if first_num >= second_num else second_num
							lowerCamelCase_								=max_num
							while (common_mult % first_num > 0) or (common_mult % second_num > 0):
														common_mult += max_num
							return common_mult




def        __UpperCamelCase     (      _A					:							int      ,  _A					:							int		)				->int:



							"""simple docstring"""
							return b if a == 0 else greatest_common_divisor(b % a      ,  _A		)




def        __UpperCamelCase     (      _A					:							int      ,  _A					:							int		)				->int:



							"""simple docstring"""
							return first_num // greatest_common_divisor(_A      ,  _A		) * second_num




def        __UpperCamelCase     (      )				->str:



							"""simple docstring"""
							lowerCamelCase_								=(
							    """from __main__ import least_common_multiple_slow, least_common_multiple_fast"""
							)
							print(
							    """least_common_multiple_slow():"""      ,  timeit("""least_common_multiple_slow(1000, 999)"""      ,  setup=_A		)      ,  )
							print(
							    """least_common_multiple_fast():"""      ,  timeit("""least_common_multiple_fast(1000, 999)"""      ,  setup=_A		)      ,  )


class 			_SCREAMING_SNAKE_CASE      (  unittest.TestCase):
						_UpperCamelCase:Union[str, Any]	=		(
						    (10, 20),
						    (13, 15),
						    (4, 31),
						    (10, 42),
						    (43, 34),
						    (5, 12),
						    (12, 25),
						    (10, 25),
						    (6, 9),
						)
						_UpperCamelCase:List[str]	=		(20, 1_95, 1_24, 2_10, 14_62, 60, 3_00, 50, 18)







						def        _snake_case				(			self							)->							Any:
													for i, (first_num, second_num) in enumerate(self.test_inputs							):
																				lowerCamelCase_								=least_common_multiple_slow(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							)
																				lowerCamelCase_								=least_common_multiple_fast(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							)
																				with self.subTest(i=_SCREAMING_SNAKE_CASE							):
																											self.assertEqual(_SCREAMING_SNAKE_CASE     ,						self.expected_results[i]							)
																											self.assertEqual(_SCREAMING_SNAKE_CASE     ,						self.expected_results[i]							)


if __name__ == "__main__":
	benchmark()
	unittest.main()



def        __UpperCamelCase     (      _A					:							str		)				->int:



							"""simple docstring"""
							lowerCamelCase_								=lowerCamelCase_								=0
							for letter in data:
														lowerCamelCase_								=(hash_ << 4) + ord(_A		)
														lowerCamelCase_								=hash_ & 0XF0000000
														if x != 0:
																					hash_ ^= x >> 24
														hash_ &= ~x
							return hash_


if __name__ == "__main__":
	import doctest

	doctest.testmod()
