


'''simple docstring'''

import unittest
from timeit import timeit



def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int    ,		_UpperCamelCase      :				int   )		->					int:





   '''simple docstring'''







   UpperCamelCase__ 						=						first_num if first_num >= second_num else second_num
   UpperCamelCase__ 						=						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      :				int    ,		_UpperCamelCase      :				int   )		->					int:





   '''simple docstring'''







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



def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int    ,		_UpperCamelCase      :				int   )		->					int:





   '''simple docstring'''







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



def        SCREAMING_SNAKE_CASE__(		)		->					str:





   '''simple docstring'''







   UpperCamelCase__ 						=						(
       "from __main__ import least_common_multiple_slow, least_common_multiple_fast"
   )
   print(
       "least_common_multiple_slow():"    ,		timeit("least_common_multiple_slow(1000, 999)"    ,		setup=_UpperCamelCase   )    ,		)
   print(
       "least_common_multiple_fast():"    ,		timeit("least_common_multiple_fast(1000, 999)"    ,		setup=_UpperCamelCase   )    ,		)







class  UpperCAmelCase (       unittest.TestCase):
 _lowerCamelCase :					str    					=					(
     (10, 20),
     (13, 15),
     (4, 31),
     (10, 42),
     (43, 34),
     (5, 12),
     (12, 25),
     (10, 25),
     (6, 9),
 )
 _lowerCamelCase :					int    					=					(20, 195, 124, 210, 1462, 60, 300, 50, 18)

 def 		lowercase_						( self :	List[Any]					):





    """simple docstring"""



    for i, (first_num, second_num) in enumerate(self.test_inputs					):
       UpperCamelCase__ 						=						least_common_multiple_slow(a_,					a_					)
       UpperCamelCase__ 						=						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()



'''simple docstring'''

from typing import TYPE_CHECKING

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


__lowercase:		int							=     {
    "configuration_open_llama": ["OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenLlamaConfig"],
}

try:
       if not is_sentencepiece_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase:		str							=     ["LlamaTokenizer"]

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase:		List[Any]							=     ["LlamaTokenizerFast"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase:		Union[str, Any]							=     [
           "OpenLlamaForCausalLM",
           "OpenLlamaModel",
           "OpenLlamaPreTrainedModel",
           "OpenLlamaForSequenceClassification",
       ]


if TYPE_CHECKING:
       from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig

       try:
              if not is_sentencepiece_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from transformers import LlamaTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from transformers import LlamaTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_open_llama import (
                  OpenLlamaForCausalLM,
                  OpenLlamaForSequenceClassification,
                  OpenLlamaModel,
                  OpenLlamaPreTrainedModel,
              )


else:
       import sys

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