
'''simple docstring'''





import unittest
from timeit import timeit





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      int:







      """simple docstring"""
      __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 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      int:







      """simple docstring"""
      return b if a == 0 else greatest_common_divisor(b % a   ,	UpperCAmelCase						)





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      int:







      """simple docstring"""
      return first_num // greatest_common_divisor(UpperCAmelCase   ,	UpperCAmelCase						) * second_num





def 							snake_case				(		)->      Any:







      """simple docstring"""
      __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=UpperCAmelCase						)   ,	)
      print(
          'least_common_multiple_fast():'   ,	timeit('least_common_multiple_fast(1000, 999)'   ,	setup=UpperCAmelCase						)   ,	)


class 			UpperCamelCase__	(     unittest.TestCase):
 UpperCAmelCase__     :     Any    					=       (
     (1_0, 2_0),
     (1_3, 1_5),
     (4, 3_1),
     (1_0, 4_2),
     (4_3, 3_4),
     (5, 1_2),
     (1_2, 2_5),
     (1_0, 2_5),
     (6, 9),
 )
 UpperCAmelCase__     :     Dict    					=       (2_0, 1_9_5, 1_2_4, 2_1_0, 1_4_6_2, 6_0, 3_0_0, 5_0, 1_8)






 def 						lowercase_    (      self	:List[str]      )					->      List[str]:







       '''simple docstring'''



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











from typing import Dict, List, Optional, Tuple

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_lowercase:					int      =						logging.get_logger(__name__)



class       _lowercase				(  lowerCAmelCase      ):





	"""simple docstring"""
	__A		      =				["input_ids", "attention_mask"]




	def __init__(self						,			lowerCamelCase_="[PAD]"						,			lowerCamelCase_="[BOS]"						,			lowerCamelCase_="[EOS]"						,			lowerCamelCase_="[MASK]"						,			lowerCamelCase_="[CLS]"						,			lowerCamelCase_="[SEP]"						,			lowerCamelCase_=2048						,			**lowerCamelCase_						,			):
						"""simple docstring"""

						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else pad_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else bos_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else eos_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else mask_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else cls_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else sep_token

						super().__init__(
						    pad_token=lowerCamelCase_						,			bos_token=lowerCamelCase_						,			eos_token=lowerCamelCase_						,			mask_token=lowerCamelCase_						,			cls_token=lowerCamelCase_						,			sep_token=lowerCamelCase_						,			model_max_length=lowerCamelCase_						,			**lowerCamelCase_						,			)

						a   	=  2**8  # utf is 8 bits

						# define special tokens dict
						a   	=  {
						    self.pad_token: 0,
						    self.bos_token: 1,
						    self.eos_token: 2,
						    self.mask_token: 3,
						    self.cls_token: 4,
						    self.sep_token: 5,
						}
						a   	=  len(self.special_tokens_encoder						)
						a   	=  {v: k for k, v in self.special_tokens_encoder.items()}




	def 	UpperCamelCase_			(self						):
						"""simple docstring"""

						a   	=  self.special_tokens_encoder.copy()
						vocab.update(self.added_tokens_encoder						)
						for i in range(self._utf_vocab_size						):
											a   	=  chr(lowerCamelCase_						)
											a   	=  i + len(self.special_tokens_encoder						)
						return vocab




	@property
	def 	UpperCamelCase_			(self						):
						"""simple docstring"""

						return self._utf_vocab_size + self._num_special_tokens




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						,			lowerCamelCase_ = None						,			lowerCamelCase_ = False						):
						"""simple docstring"""

						if already_has_special_tokens:
											return super().get_special_tokens_mask(
											    token_ids_a=lowerCamelCase_						,			token_ids_a=lowerCamelCase_						,			already_has_special_tokens=lowerCamelCase_						)

						# normal case: some special tokens
						if token_ids_a is None:
											return [1] + [0] * len(lowerCamelCase_						) + [1]
						return [1] + ([0] * len(lowerCamelCase_						)) + [1] + ([0] * len(lowerCamelCase_						)) + [1]




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						,			lowerCamelCase_ = None						):
						"""simple docstring"""

						if token_ids_a is None:
											return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
						else:
											return [self.cls_token_id] + token_ids_a + [self.sep_token_id] + token_ids_a + [self.sep_token_id]




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						a   	=  [chr(lowerCamelCase_						) for i in text.encode("utf-8"						)]
						return tokens




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						if token in self.special_tokens_encoder:
											a   	=  self.special_tokens_encoder[token]
						elif token in self.added_tokens_encoder:
											a   	=  self.added_tokens_encoder[token]
						elif len(lowerCamelCase_						) != 1:
											a   	=  self.unk_token_id
						else:
											a   	=  ord(lowerCamelCase_						) + self._num_special_tokens
						return token_id




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						if index in self.special_tokens_decoder:
											a   	=  self.special_tokens_decoder[index]
						elif index in self.added_tokens_decoder:
											a   	=  self.added_tokens_decoder[index]
						else:
											a   	=  chr(index - self._num_special_tokens						)
						return token




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						a   	=  B""
						for token in tokens:
											if token in self.special_tokens_decoder:
																a   	=  self.special_tokens_decoder[token].encode("utf-8"						)
											elif token in self.added_tokens_decoder:
																a   	=  self.special_tokens_decoder[token].encode("utf-8"						)
											elif token in self.special_tokens_encoder:
																a   	=  token.encode("utf-8"						)
											elif token in self.added_tokens_encoder:
																a   	=  token.encode("utf-8"						)
											else:
																a   	=  bytes([ord(lowerCamelCase_						)]						)
											bstring += tok_string
						a   	=  bstring.decode("utf-8"						,			errors="replace"						)
						return string




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						,			lowerCamelCase_ = None						):
						"""simple docstring"""

						return ()
