






'''simple docstring'''
import os
import re
import unicodedata
from shutil import copyfile
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union

import sentencepiece as spm

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


if is_torch_available():
      import torch


if TYPE_CHECKING:
      from transformers.pipelines.conversational import Conversation


a_					=	logging.get_logger(__name__)
a_					=	{"vocab_file": "spiece.model"}

a_					=	{
    "vocab_file": {
        "AI-Sweden/gpt-sw3-126m": "https://huggingface.co/AI-Sweden/gpt-sw3-126m/resolve/main/spiece.model",
        "AI-Sweden/gpt-sw3-350m": "https://huggingface.co/AI-Sweden/gpt-sw3-350m/resolve/main/spiece.model",
        "AI-Sweden/gpt-sw3-1.6b": "https://huggingface.co/AI-Sweden/gpt-sw3-1.6b/resolve/main/spiece.model",
        "AI-Sweden/gpt-sw3-6.7b": "https://huggingface.co/AI-Sweden/gpt-sw3-6.7b/resolve/main/spiece.model",
        "AI-Sweden/gpt-sw3-20b": "https://huggingface.co/AI-Sweden/gpt-sw3-20b/resolve/main/spiece.model",
    }
}

a_					=	{
    "AI-Sweden/gpt-sw3-126m": 2_0_4_8,
    "AI-Sweden/gpt-sw3-350m": 2_0_4_8,
    "AI-Sweden/gpt-sw3-1.6b": 2_0_4_8,
    "AI-Sweden/gpt-sw3-6.7b": 2_0_4_8,
    "AI-Sweden/gpt-sw3-20b": 2_0_4_8,
}






class        __SCREAMING_SNAKE_CASE (     UpperCAmelCase__			):
 snake_case_												=							VOCAB_FILES_NAMES
 snake_case_												=							PRETRAINED_VOCAB_FILES_MAP
 snake_case_												=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 snake_case_												=							['input_ids', 'attention_mask']




 def __init__( self		:							int   , __lowercase		:							Optional[int]   , __lowercase		:							List[Any]=False   , __lowercase		:							Optional[int]=False   , __lowercase		:							Union[str, Any]=False   , __lowercase		:							List[Any]=None   , __lowercase		:							Optional[int]=None   , __lowercase		:							Tuple=None   , __lowercase		:							Optional[int]=None   , __lowercase		:							Optional[Any] = None   , **__lowercase		:							Union[str, Any]   , )		->  None:
       SCREAMING_SNAKE_CASE__       :			List[Any]													={} if sp_model_kwargs is None else sp_model_kwargs

       SCREAMING_SNAKE_CASE__       :			List[Any]													=kwargs.get('''name_or_path''' )
       if name_or_path is None:
             logger.warning(
                 '''name_or_path not provided, will work for all GPTSw3 models except gpt-sw3-7b,'''
                 ''' you are testing the model, this can safely be ignored''' )
             SCREAMING_SNAKE_CASE__       :			str													="""None"""

       # Default definitions for our 2 tokenizer versions, with None-checks to enable proper testing
       SCREAMING_SNAKE_CASE__       :			List[str]													="""<|endoftext|>""" if eos_token is None else eos_token
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													="""<unk>""" if unk_token is None else unk_token
       if "gpt-sw3-7b" in name_or_path:
             SCREAMING_SNAKE_CASE__       :			Tuple													=unk_token if pad_token is None else pad_token
             SCREAMING_SNAKE_CASE__       :			Dict													=eos_token if bos_token is None else bos_token
       else:
             SCREAMING_SNAKE_CASE__       :			Optional[Any]													="""<pad>""" if pad_token is None else pad_token
             SCREAMING_SNAKE_CASE__       :			int													="""<s>""" if bos_token is None else bos_token

       super().__init__(
           do_lower_case=_SCREAMING_SNAKE_CASE   , remove_space=_SCREAMING_SNAKE_CASE   , keep_accents=_SCREAMING_SNAKE_CASE   , bos_token=_SCREAMING_SNAKE_CASE   , eos_token=_SCREAMING_SNAKE_CASE   , unk_token=_SCREAMING_SNAKE_CASE   , pad_token=_SCREAMING_SNAKE_CASE   , sp_model_kwargs=self.sp_model_kwargs   , **_SCREAMING_SNAKE_CASE   , )

       SCREAMING_SNAKE_CASE__       :			Optional[int]													=do_lower_case
       SCREAMING_SNAKE_CASE__       :			int													=remove_space
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=keep_accents
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=vocab_file

       SCREAMING_SNAKE_CASE__       :			List[str]													=spm.SentencePieceProcessor(**self.sp_model_kwargs )
       self.sp_model.Load(_SCREAMING_SNAKE_CASE )

       # Used for whitespace normalization in input texts
       # fmt : off
       SCREAMING_SNAKE_CASE__       :			str													={""" """, """ """, """ """, """ """, """ """, """　""", """ """, """ """, """ """, """ """, """￼""", """"""}
       # fmt : on

       # Regular expression to remove non-printing characters (e.g. some unicode control chars) in preprocessing
       SCREAMING_SNAKE_CASE__       :			List[Any]													=re.compile(
           F"[{''.join(map(_SCREAMING_SNAKE_CASE   , list(range(0   , 9 ) ) + list(range(11   , 32 ) ) + list(range(1_27   , 1_60 ) ) + [1_60, 1_73, 82_03] ) )}]" )




 def __getstate__( self		:							Union[str, Any] )		->  Dict:
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=self.__dict__.copy()
       SCREAMING_SNAKE_CASE__       :			List[str]													=None
       return state




 def __setstate__( self		:							Optional[Any]   , __lowercase		:							Tuple )		->  Dict:
       SCREAMING_SNAKE_CASE__       :			List[Any]													=d

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

       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=spm.SentencePieceProcessor(**self.sp_model_kwargs )
       self.sp_model.Load(self.vocab_file )




 @property
 # Copied from transformers.models.albert.tokenization_albert.AlbertTokenizer.vocab_size
 def        __magic_name__		( self		:							Dict )		->  int:
       return len(self.sp_model )




 def        __magic_name__		( self		:							str   , __lowercase		:							str )		->  str:
       SCREAMING_SNAKE_CASE__       :			Tuple													=self.non_printing_characters_re.sub(''''''   , _SCREAMING_SNAKE_CASE )

       # Normalize whitespaces
       SCREAMING_SNAKE_CASE__       :			str													="""""".join([char if char not in self.whitespaces else ''' ''' for char in text] )

       # NFC Unicode normalization
       SCREAMING_SNAKE_CASE__       :			Any													=unicodedata.normalize('''NFC'''   , _SCREAMING_SNAKE_CASE )
       return text




 def        __magic_name__		( self		:							Any   , __lowercase		:							Dict   , **__lowercase		:							int )		->  List[str]:
       SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=self.preprocess_text(_SCREAMING_SNAKE_CASE )
       return self.sp_model.encode(_SCREAMING_SNAKE_CASE   , out_type=_SCREAMING_SNAKE_CASE )




 def        __magic_name__		( self		:							int   , __lowercase		:							str )		->  int:
       return self.sp_model.PieceToId(_SCREAMING_SNAKE_CASE )




 def        __magic_name__		( self		:							Any   , __lowercase		:							Optional[int] )		->  str:
       return self.sp_model.IdToPiece(_SCREAMING_SNAKE_CASE )




 @staticmethod
 def        __magic_name__		( __lowercase		:							str )		->  str:
       return out_string




 def        __magic_name__		( self		:							Any   , __lowercase		:							List[Any] )		->  str:
       SCREAMING_SNAKE_CASE__       :			Any													=[]
       SCREAMING_SNAKE_CASE__       :			Dict													=""""""
       SCREAMING_SNAKE_CASE__       :			Optional[int]													=False
       for token in tokens:
             # make sure that special tokens are not decoded using sentencepiece model
             if token in self.all_special_tokens:
                   # TODO: Check if this is needed, as it ensures that decode(encode(doc)) != doc by adding extra whitespace in the decoded document
                   if not prev_is_special:
                         out_string += " "

                   out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE ) + token
                   SCREAMING_SNAKE_CASE__       :			Tuple													=True
                   SCREAMING_SNAKE_CASE__       :			Optional[Any]													=[]
             else:
                   current_sub_tokens.append(_SCREAMING_SNAKE_CASE )
                   SCREAMING_SNAKE_CASE__       :			Optional[Any]													=False
       out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE )

       return out_string




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




 def        __magic_name__		( self		:							Dict   , __lowercase		:							str   , __lowercase		:							Tuple = None )		->  Tuple[str]:




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

       if os.path.abspath(self.vocab_file ) != os.path.abspath(_SCREAMING_SNAKE_CASE ) and os.path.isfile(self.vocab_file ):
             copyfile(self.vocab_file   , _SCREAMING_SNAKE_CASE )
       elif not os.path.isfile(self.vocab_file ):
             with open(_SCREAMING_SNAKE_CASE   , '''wb''' ) as fi:
                   SCREAMING_SNAKE_CASE__       :			Optional[Any]													=self.sp_model.serialized_model_proto()
                   fi.write(_SCREAMING_SNAKE_CASE )

       return (out_vocab_file,)




 def        __magic_name__		( self		:							List[Any]   , __lowercase		:							List[str]   , __lowercase		:							List[str] = False )		->  Union[List[int], List[List[int]], "torch.Tensor"]:




       if isinstance(_SCREAMING_SNAKE_CASE   , _SCREAMING_SNAKE_CASE ):
             SCREAMING_SNAKE_CASE__       :			Optional[Any]													=self.preprocess_text(_SCREAMING_SNAKE_CASE )
             SCREAMING_SNAKE_CASE__       :			Optional[Any]													=self.sp_model.encode(_SCREAMING_SNAKE_CASE )
       else:
             SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=[self.preprocess_text(_SCREAMING_SNAKE_CASE ) for t in text]
             SCREAMING_SNAKE_CASE__       :			str													=self.sp_model.encode(_SCREAMING_SNAKE_CASE )

       if return_tensors is True or return_tensors == "pt":
             SCREAMING_SNAKE_CASE__       :			List[str]													=torch.tensor(_SCREAMING_SNAKE_CASE )

       return token_ids




 def        __magic_name__		( self		:							str   , __lowercase		:							List[str] )		->  str:
       return self.sp_model.decode(_SCREAMING_SNAKE_CASE )




 def        __magic_name__		( self		:							Union[str, Any]   , __lowercase		:							Optional[Any] )		->  List[int]:
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=[F"User: {text}" if is_user else F"Bot: {text}" for is_user, text in conversation.iter_texts()]
       SCREAMING_SNAKE_CASE__       :			Any													=(
           F"{self.eos_token}{self.bos_token}" + F"{self.bos_token}".join(_SCREAMING_SNAKE_CASE ) + F"{self.bos_token}Bot:"
       )
       return self.encode(text=_SCREAMING_SNAKE_CASE )







'''simple docstring'''
from math import factorial





def 	_a(					UpperCamelCase__			:  int = 1_0_0							):




      '''simple docstring'''






      return sum(int(UpperCamelCase__							) for x in str(factorial(UpperCamelCase__							)							)							)


if __name__ == "__main__":
  print(solution(int(input('Enter the Number: ').strip())))