

"""simple docstring"""

import unittest
from timeit import timeit





def 					__UpperCamelCase (     a__:			Any			,						a__:			Optional[Any]      )					->      int:




					"""simple docstring"""



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





def 					__UpperCamelCase (     a__:			Tuple			,						a__:			Optional[int]      )					->      int:




					"""simple docstring"""



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





def 					__UpperCamelCase (     a__:			Any			,						a__:			Any      )					->      int:




					"""simple docstring"""



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





def 					__UpperCamelCase (     )					->      int:




					"""simple docstring"""



					__lowercase        =      (
					    '''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       _snake_case  (    unittest.TestCase							):
						__snake_case			      =  (
						    (10, 20),
						    (13, 15),
						    (4, 31),
						    (10, 42),
						    (43, 34),
						    (5, 12),
						    (12, 25),
						    (10, 25),
						    (6, 9),
						)
						__snake_case			      =  (20, 195, 124, 210, 1_462, 60, 300, 50, 18)







						def 							_UpperCamelCase     (self				)      ->    int:




											for i, (first_num, second_num) in enumerate(self.test_inputs				):
																__lowercase        =      least_common_multiple_slow(UpperCAmelCase_  ,				UpperCAmelCase_				)
																__lowercase        =      least_common_multiple_fast(UpperCAmelCase_  ,				UpperCAmelCase_				)
																with self.subTest(i=UpperCAmelCase_				):
																					self.assertEqual(UpperCAmelCase_  ,				self.expected_results[i]				)
																					self.assertEqual(UpperCAmelCase_  ,				self.expected_results[i]				)


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








'''simple docstring'''






from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
lowercase						:   Any      						=							TypeVar('''T''', bound='''Enum''')

@unique
class 	SCREAMING_SNAKE_CASE_		(							lowerCamelCase_					):
 __snake_case						:  Union[str, Any]       =   8_0
 __snake_case						:  Optional[Any]       =   7_0
 __snake_case						:  List[str]       =   6_0
 __snake_case						:  str       =   5_0
 __snake_case						:  Tuple       =   4_0
 __snake_case						:  Union[str, Any]       =   3_0
 __snake_case						:  Dict       =   2_0
 __snake_case						:  str       =   1_0






@unique
class 	SCREAMING_SNAKE_CASE_		(							lowerCamelCase_					):
 __snake_case						:  Optional[Any]       =   2_4
 __snake_case						:  List[str]       =   2_1
 __snake_case						:  Any       =   1_8
 __snake_case						:  Union[str, Any]       =   1_5
 __snake_case						:  Dict       =   1_2
 __snake_case						:  Union[str, Any]       =   9
 __snake_case						:  List[str]       =   6
 __snake_case						:  Optional[int]       =   3
 __snake_case						:  Tuple       =   2
 __snake_case						:  Any       =   1
 __snake_case						:  Optional[int]       =   -1
 __snake_case						:  Optional[int]       =   -2
 __snake_case						:  str       =   -3
 __snake_case						:  Optional[Any]       =   -6
 __snake_case						:  Optional[int]       =   -9
 __snake_case						:  List[Any]       =   -1_2
 __snake_case						:  str       =   -1_5
 __snake_case						:  str       =   -1_8
 __snake_case						:  Dict       =   -2_1
 __snake_case						:  int       =   -2_4



 @classmethod
 def  SCREAMING_SNAKE_CASE(	cls			):






        '''simple docstring'''




        return {unit.name: unit.value for unit in cls if unit.value > 0}





 @classmethod
 def  SCREAMING_SNAKE_CASE(	cls			):






        '''simple docstring'''




        return {unit.name: unit.value for unit in cls if unit.value < 0}






def 		a_(			lowerCamelCase   )					->str:






       '''simple docstring'''




       lowercase	:		Tuple    =   SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
       for name_prefix, value_prefix in prefixes.items():
              lowercase	:		Dict    =   value / (10**value_prefix)
              if numerical_part > 1:
                     return f"""{numerical_part!s} {name_prefix}"""
       return str(lowerCamelCase   )




def 		a_(			lowerCamelCase   )					->str:






       '''simple docstring'''




       for prefix in BinaryUnit:
              lowercase	:		Dict    =   value / (2**prefix.value)
              if numerical_part > 1:
                     return f"""{numerical_part!s} {prefix.name}"""
       return str(lowerCamelCase   )


if __name__ == "__main__":
      import doctest

      doctest.testmod()




