

'''simple docstring'''

import unittest
from timeit import timeit

def      __magic_name__							(			A       , A				)      ->		int:
	snake_case							=					first_num if first_num >= second_num else second_num
	snake_case							=					max_num
	while (common_mult % first_num > 0) or (common_mult % second_num > 0):
		common_mult += max_num
	return common_mult

def      __magic_name__							(			A       , A				)      ->		int:
	return b if a == 0 else greatest_common_divisor(b % a       , A				)

def      __magic_name__							(			A       , A				)      ->		int:
	return first_num // greatest_common_divisor(A       , A				) * second_num

def      __magic_name__							(			)      ->		Any:
	snake_case							=					(
	    'from __main__ import least_common_multiple_slow, least_common_multiple_fast'
	)
	print(
	    'least_common_multiple_slow():'       , timeit('least_common_multiple_slow(1000, 999)'       , setup=A				)       , )
	print(
	    'least_common_multiple_fast():'       , timeit('least_common_multiple_fast(1000, 999)'       , setup=A				)       , )







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

				def 					_lowerCamelCase    (       self )    ->							Optional[Any]:
					for i, (first_num, second_num) in enumerate(self.test_inputs ):
						snake_case							=					least_common_multiple_slow(lowercase_,						lowercase_ )
						snake_case							=					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()









import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_mpnet import MPNetTokenizer


UpperCAmelCase__        =				logging.get_logger(__name__)

UpperCAmelCase__        =				{'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

UpperCAmelCase__        =				{
    '''vocab_file''': {
        '''microsoft/mpnet-base''': '''https://huggingface.co/microsoft/mpnet-base/resolve/main/vocab.txt''',
    },
    '''tokenizer_file''': {
        '''microsoft/mpnet-base''': '''https://huggingface.co/microsoft/mpnet-base/resolve/main/tokenizer.json''',
    },
}

UpperCAmelCase__        =				{
    '''microsoft/mpnet-base''': 512,
}

UpperCAmelCase__        =				{
    '''microsoft/mpnet-base''': {'''do_lower_case''': True},
}







class  lowerCamelCase__  (			lowerCAmelCase):
     SCREAMING_SNAKE_CASE__      =     VOCAB_FILES_NAMES
     SCREAMING_SNAKE_CASE__      =     PRETRAINED_VOCAB_FILES_MAP
     SCREAMING_SNAKE_CASE__      =     PRETRAINED_INIT_CONFIGURATION
     SCREAMING_SNAKE_CASE__      =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     SCREAMING_SNAKE_CASE__      =     MPNetTokenizer
     SCREAMING_SNAKE_CASE__      =     ['''input_ids''', '''attention_mask''']





     def __init__(self						,	UpperCAmelCase=None						,	UpperCAmelCase=None						,	UpperCAmelCase=True						,	UpperCAmelCase="<s>"						,	UpperCAmelCase="</s>"						,	UpperCAmelCase="</s>"						,	UpperCAmelCase="<s>"						,	UpperCAmelCase="[UNK]"						,	UpperCAmelCase="<pad>"						,	UpperCAmelCase="<mask>"						,	UpperCAmelCase=True						,	UpperCAmelCase=None						,	**UpperCAmelCase						,	)	->  Optional[int]:
      super().__init__(
          UpperCAmelCase						,	tokenizer_file=UpperCAmelCase						,	do_lower_case=UpperCAmelCase						,	bos_token=UpperCAmelCase						,	eos_token=UpperCAmelCase						,	sep_token=UpperCAmelCase						,	cls_token=UpperCAmelCase						,	unk_token=UpperCAmelCase						,	pad_token=UpperCAmelCase						,	mask_token=UpperCAmelCase						,	tokenize_chinese_chars=UpperCAmelCase						,	strip_accents=UpperCAmelCase						,	**UpperCAmelCase						,	)

      _lowercase				 =json.loads(self.backend_tokenizer.normalizer.__getstate__()			)
      if (
          pre_tok_state.get('''lowercase'''						,	UpperCAmelCase			) != do_lower_case
          or pre_tok_state.get('''strip_accents'''						,	UpperCAmelCase			) != strip_accents
      ):
       _lowercase				 =getattr(UpperCAmelCase						,	pre_tok_state.pop('''type'''			)			)
       _lowercase				 =do_lower_case
       _lowercase				 =strip_accents
       _lowercase				 =pre_tok_class(**UpperCAmelCase			)

      _lowercase				 =do_lower_case





     @property
     def 	__A   (self			)	->  str:
      if self._mask_token is None:
       if self.verbose:
        logger.error('''Using mask_token, but it is not set yet.'''			)
       return None
      return str(self._mask_token			)





     @mask_token.setter
     def 	__A   (self						,	UpperCAmelCase			)	->  Optional[int]:
      _lowercase				 =AddedToken(UpperCAmelCase						,	lstrip=UpperCAmelCase						,	rstrip=UpperCAmelCase			) if isinstance(UpperCAmelCase						,	UpperCAmelCase			) else value
      _lowercase				 =value





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase=None			)	->  List[str]:
      _lowercase				 =[self.bos_token_id] + token_ids_a + [self.eos_token_id]
      if token_ids_a is None:
       return output

      return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase = None			)	->  List[int]:
      _lowercase				 =[self.sep_token_id]
      _lowercase				 =[self.cls_token_id]

      if token_ids_a is None:
       return len(cls + token_ids_a + sep			) * [0]
      return len(cls + token_ids_a + sep + sep + token_ids_a + sep			) * [0]





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase = None			)	->  Tuple[str]:
      _lowercase				 =self._tokenizer.model.save(UpperCAmelCase						,	name=UpperCAmelCase			)
      return tuple(UpperCAmelCase			)

