
import unittest
from timeit import timeit





def        lowerCAmelCase       (				snake_case__   :      List[Any]				,					snake_case__   :      Union[str, Any] )->			int:
    A_								=					first_num if first_num >= second_num else second_num
    A_								=					max_num
    while (common_mult % first_num > 0) or (common_mult % second_num > 0):
        common_mult += max_num
    return common_mult





def        lowerCAmelCase       (				snake_case__   :      List[str]				,					snake_case__   :      List[Any] )->			int:
    return b if a == 0 else greatest_common_divisor(b % a				,					snake_case__ )





def        lowerCAmelCase       (				snake_case__   :      str				,					snake_case__   :      Optional[Any] )->			int:
    return first_num // greatest_common_divisor(snake_case__				,					snake_case__ ) * second_num





def        lowerCAmelCase       (				)->			Any:
    A_								=					(
        'from __main__ import least_common_multiple_slow, least_common_multiple_fast'
    )
    print(
        "least_common_multiple_slow():"				,					timeit("least_common_multiple_slow(1000, 999)"				,					setup=snake_case__ )				,					)
    print(
        "least_common_multiple_fast():"				,					timeit("least_common_multiple_fast(1000, 999)"				,					setup=snake_case__ )				,					)


class 							lowerCamelCase       (		unittest.TestCase					):



  """simple docstring"""





  lowerCAmelCase_								=		(
      (10, 20),
      (13, 15),
      (4, 31),
      (10, 42),
      (43, 34),
      (5, 12),
      (12, 25),
      (10, 25),
      (6, 9),
  )
  lowerCAmelCase_								=		(20, 195, 124, 210, 1_462, 60, 300, 50, 18)

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


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









'''simple docstring'''


from itertools import combinations, product







def     SCREAMING_SNAKE_CASE(	UpperCamelCase ,UpperCamelCase ,UpperCamelCase ,UpperCamelCase	)     ->     bool:
	if xa == ya == 0 or xa == ya == 0:
		return False
	UpperCAmelCase_		:   int													=       xa * xa + ya * ya
	UpperCAmelCase_		:   List[str]													=       xa * xa + ya * ya
	UpperCAmelCase_		:   Optional[Any]													=       (xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
	return (
	    a_square + b_square == c_square
	    or a_square + c_square == b_square
	    or b_square + c_square == a_square
	)







def     SCREAMING_SNAKE_CASE(	UpperCamelCase = 5_0	)     ->     int:
	return sum(
	    1
	    for pta, pta in combinations(product(range(limit + 1	) ,repeat=2	) ,2	)
	    if is_right(*UpperCamelCase ,*UpperCamelCase	)	)


if __name__ == "__main__":
						print(F'{solution() = }')






