





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

import sentencepiece as spm

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


snake_case_           =      '▁'

snake_case_           =      {'vocab_file': 'spiece.model'}

snake_case_           =      {
    'vocab_file': {'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model'}
}

snake_case_           =      {
    'google/pegasus-xsum': 512,
}


snake_case_           =      logging.get_logger(__name__)

class 		SCREAMING_SNAKE_CASE__    (	_UpperCAmelCase  ):
      A_						:    Dict							=   VOCAB_FILES_NAMES

      A_						:    str							=   VOCAB_FILES_NAMES
      A_						:    List[str]							=   PRETRAINED_VOCAB_FILES_MAP
      A_						:    int							=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      A_						:    Optional[int]							=   ['input_ids', 'attention_mask']


      def __init__(self	:				int    ,      a__	:				Tuple    ,      a__	:				Union[str, Any]="<pad>"    ,      a__	:				Dict="</s>"    ,      a__	:				Optional[int]="<unk>"    ,      a__	:				Union[str, Any]="<mask_2>"    ,      a__	:				Tuple="<mask_1>"    ,      a__	:				Any=None    ,      a__	:				Any=103    ,      a__	:				Optional[Dict[str, Any]] = None    ,      **a__	:				str    ,      ):





         """simple docstring"""



         __snake_case								=       offset
         if additional_special_tokens is not None:
            if not isinstance(a__    ,      a__				):
               raise TypeError(
                   f"""additional_special_tokens should be of type {type(a__				)}, but is"""
                   f""" {type(a__				)}"""				)

            __snake_case								=       (
                ([mask_token_sent] + additional_special_tokens)
                if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
                else additional_special_tokens
            )
            # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
            additional_special_tokens_extended += [
                f"""<unk_{i}>""" for i in range(len(a__				)    ,      self.offset - 1				)
            ]

            if len(set(a__				)				) != len(a__				):
               raise ValueError(
                   '''Please make sure that the provided additional_special_tokens do not contain an incorrectly'''
                   f""" shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}."""				)
            __snake_case								=       additional_special_tokens_extended
         else:
            __snake_case								=       [mask_token_sent] if mask_token_sent is not None else []
            additional_special_tokens += [f"""<unk_{i}>""" for i in range(2    ,      self.offset				)]

         __snake_case								=       {} if sp_model_kwargs is None else sp_model_kwargs

         super().__init__(
             eos_token=a__    ,      unk_token=a__    ,      mask_token=a__    ,      pad_token=a__    ,      mask_token_sent=a__    ,      offset=a__    ,      additional_special_tokens=a__    ,      sp_model_kwargs=self.sp_model_kwargs    ,      **a__    ,      )
         __snake_case								=       mask_token_sent
         __snake_case								=       vocab_file
         __snake_case								=       spm.SentencePieceProcessor(**self.sp_model_kwargs				)
         self.sp_model.Load(a__				)

         # add special tokens to encoder dict
         __snake_case								=       {
             0: self.pad_token,
             1: self.eos_token,
         }

         if self.mask_token_sent is not None:
            self.encoder.update(
                {
                    2: self.mask_token_sent,
                    3: self.mask_token,
                }				)

         if self.offset > 0:
            # entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102
            # mask_token_sent is already added to list -> so start at 1
            self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1    ,      self.offset - 1				)}				)

         __snake_case								=       {v: k for k, v in self.encoder.items()}


      @property
      def        a			(self	:				Tuple				):





         """simple docstring"""



         return len(self.sp_model				) + self.offset


      def        a			(self	:				Dict				):





         """simple docstring"""



         __snake_case								=       {self.convert_ids_to_tokens(a__				): i for i in range(self.vocab_size				)}
         vocab.update(self.added_tokens_encoder				)
         return vocab


      def __getstate__(self	:				Union[str, Any]				):





         """simple docstring"""



         __snake_case								=       self.__dict__.copy()
         __snake_case								=       None
         return state


      def __setstate__(self	:				Any    ,      a__	:				Optional[Any]				):





         """simple docstring"""



         __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	:				Dict    ,      a__	:				str				):





         """simple docstring"""



         return self.sp_model.encode(a__    ,      out_type=a__				)


      def        a			(self	:				List[Any]    ,      a__	:				str				):





         """simple docstring"""



         if token in self.decoder:
            return self.decoder[token]
         elif token in self.added_tokens_decoder:
            return self.added_tokens_decoder[token]
         __snake_case								=       self.sp_model.piece_to_id(a__				)
         return sp_id + self.offset


      def        a			(self	:				str    ,      a__	:				int				):





         """simple docstring"""



         if index in self.encoder:
            return self.encoder[index]
         elif index in self.added_tokens_encoder:
            return self.added_tokens_encoder[index]
         else:
            __snake_case								=       self.sp_model.IdToPiece(index - self.offset				)
         return token


      def        a			(self	:				Dict    ,      a__	:				int				):





         """simple docstring"""



         __snake_case								=       []
         __snake_case								=       ''''''
         for token in tokens:
            # make sure that special tokens are not decoded using sentencepiece model
            if token in self.all_special_tokens:
               out_string += self.sp_model.decode(a__				) + token
               __snake_case								=       []
            else:
               current_sub_tokens.append(a__				)
         out_string += self.sp_model.decode(a__				)
         return out_string.strip()


      def        a			(self	:				Any    ,      a__	:				int=False				):





         """simple docstring"""



         return 1


      def        a			(self	:				Optional[int]    ,      a__	:				Any				):





         """simple docstring"""



         __snake_case								=       set(self.all_special_ids				)  # call it once instead of inside list comp
         all_special_ids.remove(self.unk_token_id				)  # <unk> is only sometimes special

         return [1 if x in all_special_ids else 0 for x in seq]


      def        a			(self	:				Optional[Any]    ,      a__	:				List    ,      a__	:				Optional[List] = None    ,      a__	:				bool = False				):





         """simple docstring"""



         if already_has_special_tokens:
            return self._special_token_mask(a__				)
         elif token_ids_a is None:
            return self._special_token_mask(a__				) + [1]
         else:
            return self._special_token_mask(token_ids_a + token_ids_a				) + [1]


      def        a			(self	:				Union[str, Any]    ,      a__	:				str    ,      a__	:				Optional[int]=None				):





         """simple docstring"""



         if token_ids_a is None:
            return token_ids_a + [self.eos_token_id]
         # We don't expect to process pairs, but leave the pair logic for API consistency
         return token_ids_a + token_ids_a + [self.eos_token_id]


      def        a			(self	:				Union[str, Any]    ,      a__	:				str    ,      a__	:				Optional[str] = None				):





         """simple docstring"""



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

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

         return (out_vocab_file,)








def lowerCamelCase__   (							snake_case_     :  int = 1000	)				->    int:
   __snake_case								=       2**power
   __snake_case								=       str(snake_case_	)
   __snake_case								=       list(snake_case_	)
   __snake_case								=       0

   for i in list_num:
      sum_of_num += int(snake_case_	)

   return sum_of_num


if __name__ == "__main__":
    snake_case_           =      int(input('Enter the power of 2: ').strip())
    print('2 ^ ', power, ' = ', 2**power)
    snake_case_           =      solution(power)
    print('Sum of the digits is: ', result)

