'''simple docstring'''

def __UpperCamelCase(   ):
			'''simple docstring'''
			UpperCAmelCase__							:				Optional[Any]   				=  []
			UpperCAmelCase__							:				Optional[Any]   				=  1

			while len(_A    ) < 1e6:
						constant.append(str(_A    )    )
						i += 1

			UpperCAmelCase__							:				List[Any]   				=  ''''''.join(_A    )

			return (
			    int(constant[0]    )
			    * int(constant[9]    )
			    * int(constant[99]    )
			    * int(constant[9_99]    )
			    * int(constant[99_99]    )
			    * int(constant[9_99_99]    )
			    * int(constant[99_99_99]    )
			)


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





'''simple docstring'''

import os
from shutil import copyfile
from typing import List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


UpperCamelCase__     :	Union[str, Any]				=			logging.get_logger(__name__)

UpperCamelCase__     :	str				=			{'vocab_file': 'sentencepiece.model'}

UpperCamelCase__     :	int				=			{
    'vocab_file': {
        'google/rembert': 'https://huggingface.co/google/rembert/resolve/main/sentencepiece.model',
    },
}

UpperCamelCase__     :	Any				=			{
    'google/rembert': 256,
}


class 				_lowercase	(      lowerCAmelCase   ):
      '''simple docstring'''


      UpperCAmelCase_      :      List[Any]      							=   VOCAB_FILES_NAMES
      UpperCAmelCase_      :      List[Any]      							=   PRETRAINED_VOCAB_FILES_MAP
      UpperCAmelCase_      :      Tuple      							=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES




      def __init__(				self					,lowerCamelCase_					,lowerCamelCase_=False					,lowerCamelCase_=True					,lowerCamelCase_=True					,lowerCamelCase_="[CLS]"					,lowerCamelCase_="[SEP]"					,lowerCamelCase_="[UNK]"					,lowerCamelCase_="[SEP]"					,lowerCamelCase_="[PAD]"					,lowerCamelCase_="[CLS]"					,lowerCamelCase_="[MASK]"					,**lowerCamelCase_					,)			->			Tuple:



         '''simple docstring'''



         super().__init__(
             do_lower_case=lowerCamelCase_					,remove_space=lowerCamelCase_					,keep_accents=lowerCamelCase_					,bos_token=lowerCamelCase_					,eos_token=lowerCamelCase_					,unk_token=lowerCamelCase_					,sep_token=lowerCamelCase_					,pad_token=lowerCamelCase_					,cls_token=lowerCamelCase_					,mask_token=lowerCamelCase_					,**lowerCamelCase_					,)

         UpperCAmelCase__							:				Union[str, Any]   				=  do_lower_case
         UpperCAmelCase__							:				str   				=  remove_space
         UpperCAmelCase__							:				Optional[Any]   				=  keep_accents
         UpperCAmelCase__							:				List[Any]   				=  vocab_file

         UpperCAmelCase__							:				Dict   				=  spm.SentencePieceProcessor()
         self.sp_model.Load(lowerCamelCase_							)




      @property
      def 		lowerCAmelCase__					(				self							)			->			Optional[Any]:



         '''simple docstring'''



         return len(self.sp_model							)




      def 		lowerCAmelCase__					(				self							)			->			Dict:



         '''simple docstring'''



         UpperCAmelCase__							:				Optional[int]   				=  {self.convert_ids_to_tokens(lowerCamelCase_							): i for i in range(self.vocab_size							)}
         vocab.update(self.added_tokens_encoder							)
         return vocab




      def __getstate__(				self							)			->			Optional[Any]:



         '''simple docstring'''



         UpperCAmelCase__							:				Optional[int]   				=  self.__dict__.copy()
         UpperCAmelCase__							:				Any   				=  None
         return state




      def __setstate__(				self					,lowerCamelCase_							)			->			Optional[Any]:



         '''simple docstring'''



         UpperCAmelCase__							:				List[str]   				=  d
         UpperCAmelCase__							:				Any   				=  spm.SentencePieceProcessor()
         self.sp_model.Load(self.vocab_file							)




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_					,lowerCamelCase_=False							)			->			Tuple:



         '''simple docstring'''



         UpperCAmelCase__							:				str   				=  self.sp_model.EncodeAsPieces(lowerCamelCase_							)
         return pieces




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_							)			->			str:



         '''simple docstring'''



         return self.sp_model.PieceToId(lowerCamelCase_							)




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_							)			->			Optional[int]:



         '''simple docstring'''



         return self.sp_model.IdToPiece(lowerCamelCase_							)




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_							)			->			List[Any]:



         '''simple docstring'''



         UpperCAmelCase__							:				List[Any]   				=  self.sp_model.decode_pieces(lowerCamelCase_							)
         return out_string




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_					,lowerCamelCase_ = None							)			->			List[int]:



         '''simple docstring'''



         UpperCAmelCase__							:				Union[str, Any]   				=  [self.sep_token_id]
         UpperCAmelCase__							:				List[Any]   				=  [self.cls_token_id]
         if token_ids_a is None:
            return cls + token_ids_a + sep
         return cls + token_ids_a + sep + token_ids_a + sep




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_					,lowerCamelCase_ = None					,lowerCamelCase_ = False							)			->			List[int]:



         '''simple docstring'''



         if already_has_special_tokens:
            if token_ids_a is not None:
               raise ValueError(
                   '''You should not supply a second sequence if the provided sequence of '''
                   '''ids is already formatted with special tokens for the model.'''							)
            return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

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




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_					,lowerCamelCase_ = None							)			->			List[int]:



         '''simple docstring'''



         UpperCAmelCase__							:				Tuple   				=  [self.sep_token_id]
         UpperCAmelCase__							:				List[Any]   				=  [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							) * [0] + len(token_ids_a + sep							) * [1]




      def 		lowerCAmelCase__					(				self					,lowerCamelCase_					,lowerCamelCase_ = None							)			->			Tuple[str]:



         '''simple docstring'''



         if not os.path.isdir(lowerCamelCase_							):
            logger.error('''Vocabulary path ({}) should be a directory'''.format(lowerCamelCase_							)							)
            return
         UpperCAmelCase__							:				Union[str, Any]   				=  os.path.join(
             lowerCamelCase_					,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']							)

         if os.path.abspath(self.vocab_file							) != os.path.abspath(lowerCamelCase_							):
            copyfile(self.vocab_file					,lowerCamelCase_							)

         return (out_vocab_file,)




