code: 
  
  import unittest
  from timeit import timeit
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase    			=      first_num if first_num >= second_num else second_num
      lowerCAmelCase    			=      max_num
      while (common_mult % first_num > 0) or (common_mult % second_num > 0):
          common_mult += max_num
      return common_mult
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return b if a == 0 else greatest_common_divisor(b % a,      snake_case_				)
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return first_num // greatest_common_divisor(snake_case_,      snake_case_				) * second_num
  def 		SCREAMING_SNAKE_CASE__				(							)					-> List[Any]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase    			=      (
          '''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    __A				(							unittest.TestCase ):
      lowerCAmelCase_							:		List[Any]						=							(
          (10, 20),
          (13, 15),
          (4, 31),
          (10, 42),
          (43, 34),
          (5, 12),
          (12, 25),
          (10, 25),
          (6, 9),
      )
      lowerCAmelCase_							:		str						=							(20, 195, 124, 210, 1462, 60, 300, 50, 18)
  
  
  
  
  
  
      def 	lowercase__ (	self			:    int    ):
  
  
          for i, (first_num, second_num) in enumerate(self.test_inputs    ):
              lowerCAmelCase    			=      least_common_multiple_slow(__UpperCamelCase    ,				__UpperCamelCase    )
              lowerCAmelCase    			=      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()
  
  
  
  
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available
  
  
  __A   :     Optional[int]      =			{
      '''configuration_splinter''': ['''SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SplinterConfig'''],
      '''tokenization_splinter''': ['''SplinterTokenizer'''],
  }
  
  try:
   if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __A   :     Optional[int]      =			['''SplinterTokenizerFast''']
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __A   :     Union[str, Any]      =			[
       '''SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''SplinterForQuestionAnswering''',
       '''SplinterForPreTraining''',
       '''SplinterLayer''',
       '''SplinterModel''',
       '''SplinterPreTrainedModel''',
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_splinter import SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP, SplinterConfig
   from .tokenization_splinter import SplinterTokenizer
  
   try:
    if not is_tokenizers_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .tokenization_splinter_fast import SplinterTokenizerFast
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_splinter import (
        SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST,
        SplinterForPreTraining,
        SplinterForQuestionAnswering,
        SplinterLayer,
        SplinterModel,
        SplinterPreTrainedModel,
    )
  
  
  else:
   import sys
  
   __A   :     Optional[Any]      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
  
  