code: 
  
  
  
  
  
  import unittest
  from timeit import timeit
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      int		, _lowerCamelCase      :      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 		UpperCamelCase       (							_lowerCamelCase      :      int		, _lowerCamelCase      :      int ):
      return b if a == 0 else greatest_common_divisor(b % a		, _lowerCamelCase )
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      int		, _lowerCamelCase      :      int ):
      return first_num // greatest_common_divisor(_lowerCamelCase		, _lowerCamelCase ) * second_num
  
  
  
  
  
  def 		UpperCamelCase       (							):
      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=_lowerCamelCase )		, )
      print(
          "least_common_multiple_fast():"		, timeit("least_common_multiple_fast(1000, 999)"		, setup=_lowerCamelCase )		, )
  
  
  
  
  
  
  class      UpperCAmelCase			( unittest.TestCase       ):
   __lowercase     	=       (
       (10, 20),
       (13, 15),
       (4, 31),
       (10, 42),
       (43, 34),
       (5, 12),
       (12, 25),
       (10, 25),
       (6, 9),
   )
   __lowercase     	=       (20, 195, 124, 210, 1462, 60, 300, 50, 18)
   def   UpperCAmelCase_							(       self   :Tuple							)->							List[str]:
       for i, (first_num, second_num) in enumerate(self.test_inputs							):
           A__       =    least_common_multiple_slow(lowercase_		, lowercase_							)
           A__       =    least_common_multiple_fast(lowercase_		, lowercase_							)
           with self.subTest(i=lowercase_							):
               self.assertEqual(lowercase_		, self.expected_results[i]							)
               self.assertEqual(lowercase_		, self.expected_results[i]							)
  
  
  if __name__ == "__main__":
    benchmark()
    unittest.main()
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  __lowerCAmelCase							:			int				={
      "configuration_layoutlm": ["LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "LayoutLMConfig", "LayoutLMOnnxConfig"],
      "tokenization_layoutlm": ["LayoutLMTokenizer"],
  }
  
  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __lowerCAmelCase							:			Any				=["LayoutLMTokenizerFast"]
  
  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __lowerCAmelCase							:			Dict				=[
        "LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST",
        "LayoutLMForMaskedLM",
        "LayoutLMForSequenceClassification",
        "LayoutLMForTokenClassification",
        "LayoutLMForQuestionAnswering",
        "LayoutLMModel",
        "LayoutLMPreTrainedModel",
    ]
  
  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __lowerCAmelCase							:			str				=[
        "TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST",
        "TFLayoutLMForMaskedLM",
        "TFLayoutLMForSequenceClassification",
        "TFLayoutLMForTokenClassification",
        "TFLayoutLMForQuestionAnswering",
        "TFLayoutLMMainLayer",
        "TFLayoutLMModel",
        "TFLayoutLMPreTrainedModel",
    ]
  
  
  if TYPE_CHECKING:
    from .configuration_layoutlm import LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMConfig, LayoutLMOnnxConfig
    from .tokenization_layoutlm import LayoutLMTokenizer
  
    try:
      if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .tokenization_layoutlm_fast import LayoutLMTokenizerFast
  
    try:
      if not is_torch_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .modeling_layoutlm import (
          LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          LayoutLMForMaskedLM,
          LayoutLMForQuestionAnswering,
          LayoutLMForSequenceClassification,
          LayoutLMForTokenClassification,
          LayoutLMModel,
          LayoutLMPreTrainedModel,
      )
    try:
      if not is_tf_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .modeling_tf_layoutlm import (
          TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForQuestionAnswering,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForTokenClassification,
          TFLayoutLMMainLayer,
          TFLayoutLMModel,
          TFLayoutLMPreTrainedModel,
      )
  
  else:
    import sys
  
    __lowerCAmelCase							:			int				=_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  
  
  