

import unittest
from timeit import timeit





def    _snake_case		(snake_case_				:    int						,					snake_case_				:    int     )       ->		int:
  __UpperCAmelCase  :     Any		=    first_num if first_num >= second_num else second_num
  __UpperCAmelCase  :     Any		=    max_num
  while (common_mult % first_num > 0) or (common_mult % second_num > 0):
    common_mult += max_num
  return common_mult





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





def    _snake_case		(snake_case_				:    int						,					snake_case_				:    int     )       ->		int:
  return first_num // greatest_common_divisor(snake_case_						,					snake_case_     ) * second_num





def    _snake_case		()       ->		Union[str, Any]:
  __UpperCAmelCase  :     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=snake_case_     )						,					)
  print(
      'least_common_multiple_fast():'						,					timeit('least_common_multiple_fast(1000, 999)'						,					setup=snake_case_     )						,					)


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




 def 						a					( self       ):
   for i, (first_num, second_num) in enumerate(self.test_inputs       ):
     __UpperCAmelCase  :     Optional[int]		=    least_common_multiple_slow(_UpperCAmelCase     ,     _UpperCAmelCase       )
     __UpperCAmelCase  :     int		=    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()








def    _snake_case		(snake_case_				:    list						,					snake_case_				:    list     )       ->		list:
  __UpperCAmelCase  :     int		=    len(snake_case_     )
  __UpperCAmelCase  :     int		=    len(snake_case_     )
  __UpperCAmelCase  :     int		=    (
      first_input_list_length
      if first_input_list_length > second_input_list_length
      else second_input_list_length
  )
  __UpperCAmelCase  :     list		=    []
  for char_count in range(snake_case_     ):
    if char_count < first_input_list_length:
      output_result_list.append(first_input_list[char_count]     )
    if char_count < second_input_list_length:
      output_result_list.append(second_input_list[char_count]     )

  return output_result_list


if __name__ == "__main__":
      print(alternative_list_arrange(['''A''', '''B''', '''C'''], [1, 2, 3, 4, 5]), end=''' ''')





