





import unittest
from timeit import timeit

def      a    (   _lowercase :  int			,    _lowercase :  int							)  ->int:
		UpperCamelCase__								=						first_num if first_num >= second_num else second_num
		UpperCamelCase__								=						max_num
		while (common_mult % first_num > 0) or (common_mult % second_num > 0):
				common_mult += max_num
		return common_mult

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

def      a    (   _lowercase :  int			,    _lowercase :  int							)  ->int:
		return first_num // greatest_common_divisor(_lowercase			,    _lowercase							) * second_num

def      a    (   )  ->List[Any]:
		UpperCamelCase__								=						(
		    """from __main__ import least_common_multiple_slow, least_common_multiple_fast"""
		)
		print(
		    """least_common_multiple_slow():"""			,    timeit("""least_common_multiple_slow(1000, 999)"""			,    setup=_lowercase							)			,    )
		print(
		    """least_common_multiple_fast():"""			,    timeit("""least_common_multiple_fast(1000, 999)"""			,    setup=_lowercase							)			,    )




class 	_UpperCAmelCase						( unittest.TestCase       ):
					__A        = (
					    (10, 20),
					    (13, 15),
					    (4, 31),
					    (10, 42),
					    (43, 34),
					    (5, 12),
					    (12, 25),
					    (10, 25),
					    (6, 9),
					)
					__A        = (20, 1_95, 1_24, 2_10, 14_62, 60, 3_00, 50, 18)




					def 						snake_case_		(    self							)    ->	Tuple:
							for i, (first_num, second_num) in enumerate(self.test_inputs							):
									UpperCamelCase__								=						least_common_multiple_slow(__lowerCAmelCase     ,   __lowerCAmelCase							)
									UpperCamelCase__								=						least_common_multiple_fast(__lowerCAmelCase     ,   __lowerCAmelCase							)
									with self.subTest(i=__lowerCAmelCase							):
											self.assertEqual(__lowerCAmelCase     ,   self.expected_results[i]							)
											self.assertEqual(__lowerCAmelCase     ,   self.expected_results[i]							)


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












def      a    (   _lowercase :  Dict			,    _lowercase :  List[str]							)  ->List[Any]:
		if len(str(_lowercase							)							) == 1 or len(str(_lowercase							)							) == 1:
				return a * b

		UpperCamelCase__								=						max(len(str(_lowercase							)							)			,    len(str(_lowercase							)							)							)
		UpperCamelCase__								=						ma // 2

		UpperCamelCase__	,      UpperCamelCase__								=						divmod(_lowercase			,    1_0**ma							)
		UpperCamelCase__	,      UpperCamelCase__								=						divmod(_lowercase			,    1_0**ma							)

		UpperCamelCase__								=						karatsuba(_lowercase			,    _lowercase							)
		UpperCamelCase__								=						karatsuba((aa + aa)			,    (ba + ba)							)
		UpperCamelCase__								=						karatsuba(_lowercase			,    _lowercase							)

		return (z * 1_0 ** (2 * ma)) + ((y - z - x) * 1_0 ** (ma)) + (x)

def      a    (   )  ->List[Any]:
		print(karatsuba(1_5_4_6_3			,    2_3_4_8_9							)							)


if __name__ == "__main__":
				main()





