


import unittest
from timeit import timeit







def     __magic_name__  (      lowerCAmelCase_      ,					lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_			:							Any      =       first_num if first_num >= second_num else second_num
	lowerCamelCase_			:							int      =       max_num
	while (common_mult % first_num > 0) or (common_mult % second_num > 0):
		common_mult += max_num
	return common_mult







def     __magic_name__  (      lowerCAmelCase_      ,					lowerCAmelCase_):
	'''simple docstring'''


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







def     __magic_name__  (      lowerCAmelCase_      ,					lowerCAmelCase_):
	'''simple docstring'''


	return first_num // greatest_common_divisor(lowerCAmelCase_      ,					lowerCAmelCase_) * second_num







def     __magic_name__  (      ):
	'''simple docstring'''


	lowerCamelCase_			:							List[str]      =       (
	    "from __main__ import least_common_multiple_slow, least_common_multiple_fast"
	)
	print(
	    "least_common_multiple_slow():"      ,					timeit("least_common_multiple_slow(1000, 999)"      ,					setup=lowerCAmelCase_)      ,					)
	print(
	    "least_common_multiple_fast():"      ,					timeit("least_common_multiple_fast(1000, 999)"      ,					setup=lowerCAmelCase_)      ,					)





class    lowerCAmelCase__				(			unittest.TestCase       ):






						"""simple docstring"""
						__UpperCAmelCase   :		int  					=	(
						    (10, 20),
						    (13, 15),
						    (4, 31),
						    (10, 42),
						    (43, 34),
						    (5, 12),
						    (12, 25),
						    (10, 25),
						    (6, 9),
						)
						__UpperCAmelCase   :		int  					=	(20, 195, 124, 210, 1462, 60, 300, 50, 18)




						def 					_UpperCamelCase			(   self     ):
							for i, (first_num, second_num) in enumerate(self.test_inputs     ):
								lowerCamelCase_			:							List[Any]      =       least_common_multiple_slow(lowercase_				,							lowercase_     )
								lowerCamelCase_			:							Any      =       least_common_multiple_fast(lowercase_				,							lowercase_     )
								with self.subTest(i=lowercase_     ):
									self.assertEqual(lowercase_				,							self.expected_results[i]     )
									self.assertEqual(lowercase_				,							self.expected_results[i]     )


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





from __future__ import annotations





class    lowerCAmelCase__				:






						"""simple docstring"""




						def __init__(   self				,							a_     ):
							lowerCamelCase_			:							List[str]      =       value
							lowerCamelCase_			:							Node | None      =       None
							lowerCamelCase_			:							Node | None      =       None





class    lowerCAmelCase__				:






						"""simple docstring"""
						__UpperCAmelCase   :		int




						def __init__(   self     ):
							lowerCamelCase_			:							str      =       0




						def 					_UpperCamelCase			(   self				,							a_				,							a_     ):
							if node is None:
								return

							if path_sum == self.target:
								self.paths += 1

							if node.left:
								self.depth_first_search(node.left				,							path_sum + node.left.value     )
							if node.right:
								self.depth_first_search(node.right				,							path_sum + node.right.value     )




						def 					_UpperCamelCase			(   self				,							a_				,							a_ = None     ):
							if node is None:
								return 0
							if target is not None:
								lowerCamelCase_			:							List[str]      =       target

							self.depth_first_search(a_				,							node.value     )
							self.path_sum(node.left     )
							self.path_sum(node.right     )

							return self.paths


if __name__ == "__main__":
							import doctest

							doctest.testmod()

