



"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase__						:							List[str]        =      {
    """configuration_deberta_v2""": ["""DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DebertaV2Config""", """DebertaV2OnnxConfig"""],
    """tokenization_deberta_v2""": ["""DebertaV2Tokenizer"""],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowercase__						:							str        =      ["""DebertaV2TokenizerFast"""]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowercase__						:							str        =      [
         """TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """TFDebertaV2ForMaskedLM""",
         """TFDebertaV2ForQuestionAnswering""",
         """TFDebertaV2ForSequenceClassification""",
         """TFDebertaV2ForTokenClassification""",
         """TFDebertaV2Model""",
         """TFDebertaV2PreTrainedModel""",
     ]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowercase__						:							str        =      [
         """DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """DebertaV2ForMaskedLM""",
         """DebertaV2ForMultipleChoice""",
         """DebertaV2ForQuestionAnswering""",
         """DebertaV2ForSequenceClassification""",
         """DebertaV2ForTokenClassification""",
         """DebertaV2Model""",
         """DebertaV2PreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_deberta_va import (
         DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
         DebertaVaConfig,
         DebertaVaOnnxConfig,
     )
     from .tokenization_deberta_va import DebertaVaTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_deberta_va_fast import DebertaVaTokenizerFast

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_deberta_va import (
              TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFDebertaVaForMaskedLM,
              TFDebertaVaForQuestionAnswering,
              TFDebertaVaForSequenceClassification,
              TFDebertaVaForTokenClassification,
              TFDebertaVaModel,
              TFDebertaVaPreTrainedModel,
          )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_deberta_va import (
              DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
              DebertaVaForMaskedLM,
              DebertaVaForMultipleChoice,
              DebertaVaForQuestionAnswering,
              DebertaVaForSequenceClassification,
              DebertaVaForTokenClassification,
              DebertaVaModel,
              DebertaVaPreTrainedModel,
          )

else:
     import sys

     lowercase__						:							Tuple        =      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)










"""simple docstring"""







import unittest
from timeit import timeit

def 							UpperCamelCase_       (       lowerCAmelCase__ :							int       ,  lowerCAmelCase__ :							int		)		->  int:

  """simple docstring"""




  lowerCAmelCase_  :							Any								=					first_num if first_num >= second_num else second_num
  lowerCAmelCase_  :							Union[str, Any]								=					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		)		->  int:

  """simple docstring"""




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

def 							UpperCamelCase_       (       lowerCAmelCase__ :							int       ,  lowerCAmelCase__ :							int		)		->  int:

  """simple docstring"""




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

def 							UpperCamelCase_       (       )		->  Dict:

  """simple docstring"""




  lowerCAmelCase_  :							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=lowerCAmelCase__		)       ,  )
  print(
      'least_common_multiple_fast():'       ,  timeit('least_common_multiple_fast(1000, 999)'       ,  setup=lowerCAmelCase__		)       ,  )







class  UpperCamelCase__  (      unittest.TestCase    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	(
          (10, 20),
          (13, 15),
          (4, 31),
          (10, 42),
          (43, 34),
          (5, 12),
          (12, 25),
          (10, 25),
          (6, 9),
      )
      _SCREAMING_SNAKE_CASE    							=	(20, 195, 124, 210, 1462, 60, 300, 50, 18)



      def 	SCREAMING_SNAKE_CASE__					( self							: List[str]			):
        for i, (first_num, second_num) in enumerate(self.test_inputs			):
          lowerCAmelCase_  :							Union[str, Any]								=					least_common_multiple_slow(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_			)
          lowerCAmelCase_  :							Any								=					least_common_multiple_fast(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_			)
          with self.subTest(i=SCREAMING_SNAKE_CASE_			):
            self.assertEqual(SCREAMING_SNAKE_CASE_       ,     self.expected_results[i]			)
            self.assertEqual(SCREAMING_SNAKE_CASE_       ,     self.expected_results[i]			)


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





