code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import unittest
  from timeit import timeit
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				str       						= first_num if first_num >= second_num else second_num
     SCREAMING_SNAKE_CASE__			:				Any       						= max_num
     while (common_mult % first_num > 0) or (common_mult % second_num > 0):
        common_mult += max_num
     return common_mult
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     return b if a == 0 else greatest_common_divisor(b % a	,     snake_case   )
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     return first_num // greatest_common_divisor(snake_case	,     snake_case   ) * second_num
  
  
  def 				UpperCamelCase	(  ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= (
         '''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 						lowercase     (   unittest.TestCase):
        __lowercase 		=  (
            (10, 20),
            (13, 15),
            (4, 31),
            (10, 42),
            (43, 34),
            (5, 12),
            (12, 25),
            (10, 25),
            (6, 9),
        )
        __lowercase 		=  (20, 1_95, 1_24, 2_10, 14_62, 60, 3_00, 50, 18)
  
  
  
  
  
  
        def    A__(self					)       ->   Union[str, Any]:
           for i, (first_num, second_num) in enumerate(self.test_inputs					):
              SCREAMING_SNAKE_CASE__			:				Any       						= least_common_multiple_slow(a__ ,  a__					)
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= least_common_multiple_fast(a__ ,  a__					)
              with self.subTest(i=a__					):
                 self.assertEqual(a__ ,  self.expected_results[i]					)
                 self.assertEqual(a__ ,  self.expected_results[i]					)
  
  
  if __name__ == "__main__":
         benchmark()
         unittest.main()
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  lowercase__			=	{
      '''+''': lambda x, y: x + y,
      '''-''': lambda x, y: x - y,
      '''*''': lambda x, y: x * y,
      '''/''': lambda x, y: x / y,
  }
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     return c.isdigit()
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= []
  
     # iterate over the string in reverse order
     for c in expression.split()[::-1]:
        # push operand to stack
        if is_operand(snake_case   ):
           stack.append(int(snake_case   )   )
  
        else:
           # pop values from stack can calculate the result
           # push the result onto the stack again
           SCREAMING_SNAKE_CASE__			:				Dict       						= stack.pop()
           SCREAMING_SNAKE_CASE__			:				Any       						= stack.pop()
           stack.append(calc[c](snake_case	,     snake_case   )   )
  
     return stack.pop()
  
  
  # Driver code
  if __name__ == "__main__":
         lowercase__			=	'''+ 9 * 2 6'''
         print(evaluate(test_expression))
  
         lowercase__			=	'''/ * 10 2 + 4 1 '''
         print(evaluate(test_expression))
  
  