



"""simple docstring"""




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

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


_UpperCamelCase: Tuple										=     logging.get_logger(__name__)

_UpperCamelCase: Optional[int]										=     '▁'

_UpperCamelCase: Union[str, Any]										=     {'vocab_file': 'prophetnet.tokenizer'}

_UpperCamelCase: int										=     {
    'vocab_file': {
        'microsoft/xprophetnet-large-wiki100-cased': (
            'https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/prophetnet.tokenizer'
        ),
    }
}

_UpperCamelCase: Optional[Any]										=     {
    'microsoft/xprophetnet-large-wiki100-cased': {'do_lower_case': False},
}

_UpperCamelCase: str										=     {
    'microsoft/xprophetnet-large-wiki100-cased': 5_1_2,
}


def      lowercase__   (	_UpperCAmelCase )   ->	List[Any]:






      '''simple docstring'''


      lowercase     :					Optional[int] 		=      collections.OrderedDict()
      with open(__a		,					'r'		,					encoding='utf-8' ) as reader:
            lowercase     :					int 		=      reader.readlines()
      for index, token in enumerate(__a ):
            lowercase     :					Tuple 		=      token.rstrip('\n' )
            lowercase     :					List[Any] 		=      index
      return vocab





class      a__						(  A__   ):
   _lowerCamelCase    							= VOCAB_FILES_NAMES
   _lowerCamelCase    							= PRETRAINED_VOCAB_FILES_MAP
   _lowerCamelCase    							= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _lowerCamelCase    							= ['input_ids', 'attention_mask']


   def __init__(							self					:							Optional[Any],   lowerCAmelCase					:							List[Any],   lowerCAmelCase					:							Optional[Any]="[SEP]",   lowerCAmelCase					:							Any="[SEP]",   lowerCAmelCase					:							Union[str, Any]="[SEP]",   lowerCAmelCase					:							Any="[UNK]",   lowerCAmelCase					:							Any="[PAD]",   lowerCAmelCase					:							Optional[Any]="[CLS]",   lowerCAmelCase					:							List[str]="[MASK]",   lowerCAmelCase					:							Dict = None,   **lowerCAmelCase					:							Tuple,   )			->				int:
         lowercase     :					Any 		=      {} if sp_model_kwargs is None else sp_model_kwargs

         super().__init__(
             bos_token=UpperCamelCase_,   eos_token=UpperCamelCase_,   sep_token=UpperCamelCase_,   unk_token=UpperCamelCase_,   pad_token=UpperCamelCase_,   cls_token=UpperCamelCase_,   mask_token=UpperCamelCase_,   sp_model_kwargs=self.sp_model_kwargs,   **UpperCamelCase_,   )

         try:
               import sentencepiece as spm
         except ImportError:
               logger.warning(
                   'You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'
                   ' pip install sentencepiece'	)
               raise

         lowercase     :					str 		=      spm.SentencePieceProcessor(**self.sp_model_kwargs	)
         self.sp_model.Load(str(UpperCamelCase_	)	)
         lowercase     :					Dict 		=      vocab_file

         # Original fairseq vocab and spm vocab must be "aligned":
         # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
         # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
         # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
         # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

         # put special tokens and [unused] tokens into the vocab
         lowercase     :					Any 		=      {'''[PAD]''': 0, '''[CLS]''': 1, '''[SEP]''': 2, '''[UNK]''': 3, '''[MASK]''': 4}

         for i in range(10	):
               lowercase     :					str 		=      f'''[unused{i}]'''
               lowercase     :					Dict 		=      5 + i

         # The first "real" token "," has position 15 in the embedding vocab and position 3 in the spm vocab
         lowercase     :					str 		=      12
         lowercase     :					int 		=      {v: k for k, v in self.fairseq_tokens_to_ids.items()}
         for k in self.fairseq_tokens_to_ids.keys():
               self.unique_no_split_tokens.append(UpperCamelCase_	)


   def __getstate__(							self					:							List[Any]	)			->				Optional[int]:
         lowercase     :					Tuple 		=      self.__dict__.copy()
         lowercase     :					Optional[Any] 		=      None
         return state


   def __setstate__(							self					:							Tuple,   lowerCAmelCase					:							Optional[int]	)			->				List[Any]:
         lowercase     :					Any 		=      d
         try:
               import sentencepiece as spm
         except ImportError:
               logger.warning(
                   'You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'
                   ' pip install sentencepiece'	)
               raise

         # for backward compatibility
         if not hasattr(self,   'sp_model_kwargs'	):
               lowercase     :					Optional[Any] 		=      {}

         lowercase     :					Any 		=      spm.SentencePieceProcessor(**self.sp_model_kwargs	)
         self.sp_model.Load(self.vocab_file	)


   def 				lowercase (							self					:							List[Any],   lowerCAmelCase					:							Optional[int],   lowerCAmelCase					:							str = None,   lowerCAmelCase					:							Dict = False	)			->				Tuple:


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

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


   def 				lowercase (							self					:							List[Any],   lowerCAmelCase					:							Union[str, Any],   lowerCAmelCase					:							Tuple = None	)			->				Optional[Any]:
         lowercase     :					Optional[int] 		=      [self.sep_token_id]

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


   @property
   def 				lowercase (							self					:							List[Any]	)			->				List[Any]:
         return len(self.sp_model	) + self.fairseq_offset


   def 				lowercase (							self					:							int	)			->				Union[str, Any]:
         lowercase     :					Optional[int] 		=      {self.convert_ids_to_tokens(UpperCamelCase_	): i for i in range(self.vocab_size	)}
         vocab.update(self.added_tokens_encoder	)
         return vocab


   def 				lowercase (							self					:							List[str],   lowerCAmelCase					:							Optional[Any]	)			->				int:
         return self.sp_model.encode(UpperCamelCase_,   out_type=UpperCamelCase_	)


   def 				lowercase (							self					:							Tuple,   lowerCAmelCase					:							Any	)			->				Dict:


         if token in self.fairseq_tokens_to_ids:
               return self.fairseq_tokens_to_ids[token]
         lowercase     :					Tuple 		=      self.sp_model.PieceToId(UpperCamelCase_	)

         # Need to return unknown token if the SP model returned 0
         return spm_id + self.fairseq_offset if spm_id else self.unk_token_id


   def 				lowercase (							self					:							List[str],   lowerCAmelCase					:							List[str]	)			->				List[str]:


         if index in self.fairseq_ids_to_tokens:
               return self.fairseq_ids_to_tokens[index]
         return self.sp_model.IdToPiece(index - self.fairseq_offset	)


   def 				lowercase (							self					:							List[str],   lowerCAmelCase					:							str	)			->				str:
         lowercase     :					Tuple 		=      ''''''.join(UpperCamelCase_	).replace(UpperCamelCase_,   ' '	).strip()
         return out_string


   def 				lowercase (							self					:							Union[str, Any],   lowerCAmelCase					:							Optional[Any],   lowerCAmelCase					:							str = None	)			->				Union[str, Any]:


         if not os.path.isdir(UpperCamelCase_	):
               logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''	)
               return
         lowercase     :					str 		=      os.path.join(
             UpperCamelCase_,   (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']	)

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

         return (out_vocab_file,)






   def 				lowercase (							self					:							Any,   lowerCAmelCase					:							Optional[Any],   lowerCAmelCase					:							List[str] = None	)			->				Optional[int]:


         if token_ids_a is None:
               return token_ids_a + [self.sep_token_id]
         lowercase     :					Tuple 		=      [self.sep_token_id]
         return token_ids_a + sep + token_ids_a + sep




'''simple docstring'''
def 			a      (			)  ->	Union[str, Any]:



					'''simple docstring'''






					UpperCamelCase__   :Optional[int]												= []
					UpperCamelCase__   :int												= 1

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

					UpperCamelCase__   :Union[str, Any]												= ''''''.join(__a   )

					return (
					    int(constant[0]   )
					    * int(constant[9]   )
					    * int(constant[99]   )
					    * int(constant[999]   )
					    * int(constant[9999]   )
					    * int(constant[99999]   )
					    * int(constant[999999]   )
					)


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