

import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


_UpperCAmelCase		:       Optional[int]						    =	logging.get_logger(__name__)

_UpperCAmelCase		:       Optional[int]						    =	{"""vocab_file""": """spiece.model"""}

_UpperCAmelCase		:       List[str]						    =	{
    """vocab_file""": {
        """xlnet-base-cased""": """https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model""",
        """xlnet-large-cased""": """https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model""",
    }
}

_UpperCAmelCase		:       Tuple						    =	{
    """xlnet-base-cased""": None,
    """xlnet-large-cased""": None,
}

# Segments (not really needed)
_UpperCAmelCase		:       Union[str, Any]						    =	0
_UpperCAmelCase		:       Optional[Any]						    =	1
_UpperCAmelCase		:       Dict						    =	2
_UpperCAmelCase		:       Optional[Any]						    =	3
_UpperCAmelCase		:       Union[str, Any]						    =	4







class 			lowercase    (	lowercase_      ):
				__SCREAMING_SNAKE_CASE :			str	      =      VOCAB_FILES_NAMES
				__SCREAMING_SNAKE_CASE :			Optional[Any]	      =      PRETRAINED_VOCAB_FILES_MAP
				__SCREAMING_SNAKE_CASE :			Union[str, Any]	      =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      '''left'''




				def __init__( self				,       snake_case				,       snake_case=False				,       snake_case=True				,       snake_case=False				,       snake_case="<s>"				,       snake_case="</s>"				,       snake_case="<unk>"				,       snake_case="<sep>"				,       snake_case="<pad>"				,       snake_case="<cls>"				,       snake_case="<mask>"				,       snake_case=["<eop>", "<eod>"]				,       snake_case = None				,       **snake_case				,       ):
											# Mask token behave like a normal word, i.e. include the space before it
											snake_case_          =   AddedToken(snake_case				,       lstrip=snake_case				,       rstrip=snake_case	) if isinstance(snake_case				,       snake_case	) else mask_token

											snake_case_          =   {} if sp_model_kwargs is None else sp_model_kwargs

											super().__init__(
											    do_lower_case=snake_case				,       remove_space=snake_case				,       keep_accents=snake_case				,       bos_token=snake_case				,       eos_token=snake_case				,       unk_token=snake_case				,       sep_token=snake_case				,       pad_token=snake_case				,       cls_token=snake_case				,       mask_token=snake_case				,       additional_special_tokens=snake_case				,       sp_model_kwargs=self.sp_model_kwargs				,       **snake_case				,       )

											snake_case_          =   3

											snake_case_          =   do_lower_case
											snake_case_          =   remove_space
											snake_case_          =   keep_accents
											snake_case_          =   vocab_file

											snake_case_          =   spm.SentencePieceProcessor(**self.sp_model_kwargs	)
											self.sp_model.Load(snake_case	)




				@property
				def    a							( self	):
											return len(self.sp_model	)




				def    a							( self	):
											snake_case_          =   {self.convert_ids_to_tokens(snake_case	): i for i in range(self.vocab_size	)}
											vocab.update(self.added_tokens_encoder	)
											return vocab




				def __getstate__( self	):
											snake_case_          =   self.__dict__.copy()
											snake_case_          =   None
											return state




				def __setstate__( self				,       snake_case	):
											snake_case_          =   d

											# for backward compatibility
											if not hasattr(self				,       'sp_model_kwargs'	):
																		snake_case_          =   {}

											snake_case_          =   spm.SentencePieceProcessor(**self.sp_model_kwargs	)
											self.sp_model.Load(self.vocab_file	)




				def    a							( self				,       snake_case	):
											if self.remove_space:
																		snake_case_          =   ' '.join(inputs.strip().split()	)
											else:
																		snake_case_          =   inputs
											snake_case_          =   outputs.replace('``'				,       '"'	).replace('\'\''				,       '"'	)

											if not self.keep_accents:
																		snake_case_          =   unicodedata.normalize('NFKD'				,       snake_case	)
																		snake_case_          =   ''.join([c for c in outputs if not unicodedata.combining(snake_case	)]	)
											if self.do_lower_case:
																		snake_case_          =   outputs.lower()

											return outputs




				def    a							( self				,       snake_case	):
											snake_case_          =   self.preprocess_text(snake_case	)
											snake_case_          =   self.sp_model.encode(snake_case				,       out_type=snake_case	)
											snake_case_          =   []
											for piece in pieces:
																		if len(snake_case	) > 1 and piece[-1] == str(','	) and piece[-2].isdigit():
																									snake_case_          =   self.sp_model.EncodeAsPieces(piece[:-1].replace(snake_case				,       ''	)	)
																									if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
																																if len(cur_pieces[0]	) == 1:
																																							snake_case_          =   cur_pieces[1:]
																																else:
																																							snake_case_          =   cur_pieces[0][1:]
																									cur_pieces.append(piece[-1]	)
																									new_pieces.extend(snake_case	)
																		else:
																									new_pieces.append(snake_case	)

											return new_pieces




				def    a							( self				,       snake_case	):
											return self.sp_model.PieceToId(snake_case	)




				def    a							( self				,       snake_case	):
											return self.sp_model.IdToPiece(snake_case	)




				def    a							( self				,       snake_case	):
											snake_case_          =   ''.join(snake_case	).replace(snake_case				,       ' '	).strip()
											return out_string




				def    a							( self				,       snake_case				,       snake_case = False				,       snake_case = None				,       snake_case = True				,       **snake_case				,       ):
											snake_case_          =   kwargs.pop('use_source_tokenizer'				,       snake_case	)

											snake_case_          =   self.convert_ids_to_tokens(snake_case				,       skip_special_tokens=snake_case	)

											# To avoid mixing byte-level and unicode for byte-level BPT
											# we need to build string separately for added tokens and byte-level tokens
											# cf. https://github.com/huggingface/transformers/issues/1133
											snake_case_          =   []
											snake_case_          =   []
											for token in filtered_tokens:
																		if skip_special_tokens and token in self.all_special_ids:
																									continue
																		if token in self.added_tokens_encoder:
																									if current_sub_text:
																																sub_texts.append(self.convert_tokens_to_string(snake_case	)	)
																																snake_case_          =   []
																									sub_texts.append(snake_case	)
																		else:
																									current_sub_text.append(snake_case	)
											if current_sub_text:
																		sub_texts.append(self.convert_tokens_to_string(snake_case	)	)

											# Mimic the behavior of the Rust tokenizer:
											# By default, there are no spaces between special tokens
											snake_case_          =   ''.join(snake_case	)

											snake_case_          =   (
											    clean_up_tokenization_spaces
											    if clean_up_tokenization_spaces is not None
											    else self.clean_up_tokenization_spaces
											)
											if clean_up_tokenization_spaces:
																		snake_case_          =   self.clean_up_tokenization(snake_case	)
																		return clean_text
											else:
																		return text




				def    a							( self				,       snake_case				,       snake_case = None	):
											snake_case_          =   [self.sep_token_id]
											snake_case_          =   [self.cls_token_id]
											if token_ids_a is None:
																		return token_ids_a + sep + cls
											return token_ids_a + sep + token_ids_a + sep + cls




				def    a							( self				,       snake_case				,       snake_case = None				,       snake_case = False	):

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

											if token_ids_a is not None:
																		return ([0] * len(snake_case	)) + [1] + ([0] * len(snake_case	)) + [1, 1]
											return ([0] * len(snake_case	)) + [1, 1]




				def    a							( self				,       snake_case				,       snake_case = None	):
											snake_case_          =   [self.sep_token_id]
											snake_case_          =   [2]

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




				def    a							( self				,       snake_case				,       snake_case = None	):
											if not os.path.isdir(snake_case	):
																		logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''	)
																		return
											snake_case_          =   os.path.join(
											    snake_case				,       (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']	)

											if os.path.abspath(self.vocab_file	) != os.path.abspath(snake_case	) and os.path.isfile(self.vocab_file	):
																		copyfile(self.vocab_file				,       snake_case	)
											elif not os.path.isfile(self.vocab_file	):
																		with open(snake_case				,       'wb'	) as fi:
																									snake_case_          =   self.sp_model.serialized_model_proto()
																									fi.write(snake_case	)

											return (out_vocab_file,)







def  __lowerCamelCase     (			UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   1
							snake_case_          =   2
							while i * i <= n:
														snake_case_          =   0
														while n % i == 0:
																					n //= i
																					multiplicity += 1
														n_divisors *= multiplicity + 1
														i += 1
							if n > 1:
														n_divisors *= 2
							return n_divisors





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   1
							snake_case_          =   1

							while True:
														i += 1
														t_num += i

														if count_divisors(UpperCamelCase__				) > 500:
																					break

							return t_num


if __name__ == "__main__":
					print(solution())




