


'''simple docstring'''






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


__A					:  Dict											=      "▁"

__A					:  int											=      {"vocab_file": "spiece.model"}

__A					:  str											=      {
    "vocab_file": {"google/pegasus-xsum": "https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model"}
}

__A					:  str											=      {
    "google/pegasus-xsum": 512,
}


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






class    __snake_case       (   _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase    =					VOCAB_FILES_NAMES

    lowercase    =					VOCAB_FILES_NAMES
    lowercase    =					PRETRAINED_VOCAB_FILES_MAP
    lowercase    =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowercase    =					['input_ids', 'attention_mask']

    def __init__(   self    :  Optional[int]    ,						lowerCamelCase    :  str    ,						lowerCamelCase    :  int="<pad>"    ,						lowerCamelCase    :  List[str]="</s>"    ,						lowerCamelCase    :  Union[str, Any]="<unk>"    ,						lowerCamelCase    :  str="<mask_2>"    ,						lowerCamelCase    :  Tuple="<mask_1>"    ,						lowerCamelCase    :  List[str]=None    ,						lowerCamelCase    :  Optional[int]=1_03    ,						lowerCamelCase    :  Optional[Dict[str, Any]] = None    ,						**lowerCamelCase    :  Tuple    ,						)   ->  None:
      lowerCAmelCase_			:      Union[str, Any]			=   offset
      if additional_special_tokens is not None:
        if not isinstance(lowerCamelCase    ,						lowerCamelCase		):
          raise TypeError(
              F'additional_special_tokens should be of type {type(lowerCamelCase		)}, but is'
              F' {type(lowerCamelCase		)}'		)

        lowerCAmelCase_			:      str			=   (
            ([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(lowerCamelCase		)    ,						self.offset - 1		)
        ]

        if len(set(lowerCamelCase		)		) != len(lowerCamelCase		):
          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}.'		)
        lowerCAmelCase_			:      int			=   additional_special_tokens_extended
      else:
        lowerCAmelCase_			:      List[str]			=   [mask_token_sent] if mask_token_sent is not None else []
        additional_special_tokens += [F'<unk_{i}>' for i in range(2    ,						self.offset		)]

      lowerCAmelCase_			:      Tuple			=   {} if sp_model_kwargs is None else sp_model_kwargs

      super().__init__(
          eos_token=lowerCamelCase    ,						unk_token=lowerCamelCase    ,						mask_token=lowerCamelCase    ,						pad_token=lowerCamelCase    ,						mask_token_sent=lowerCamelCase    ,						offset=lowerCamelCase    ,						additional_special_tokens=lowerCamelCase    ,						sp_model_kwargs=self.sp_model_kwargs    ,						**lowerCamelCase    ,						)
      lowerCAmelCase_			:      str			=   mask_token_sent
      lowerCAmelCase_			:      Union[str, Any]			=   vocab_file
      lowerCAmelCase_			:      List[Any]			=   spm.SentencePieceProcessor(**self.sp_model_kwargs		)
      self.sp_model.Load(lowerCamelCase		)

      # add special tokens to encoder dict
      lowerCAmelCase_			:      Dict[int, str]			=   {
          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		)}		)

      lowerCAmelCase_			:      Dict[str, int]			=   {v: k for k, v in self.encoder.items()}

    @property
    def __lowercase   (   self    :  List[Any]		)   ->  int:
      return len(self.sp_model		) + self.offset

    def __lowercase   (   self    :  Optional[Any]		)   ->  Dict[str, int]:
      lowerCAmelCase_			:      List[str]			=   {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    :  Tuple		)   ->  Dict:
      lowerCAmelCase_			:      Dict			=   self.__dict__.copy()
      lowerCAmelCase_			:      Optional[Any]			=   None
      return state

    def __setstate__(   self    :  Optional[Any]    ,						lowerCamelCase    :  Optional[Any]		)   ->  str:
      lowerCAmelCase_			:      Tuple			=   d

      # for backward compatibility
      if not hasattr(self    ,						"""sp_model_kwargs"""		):
        lowerCAmelCase_			:      Tuple			=   {}

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

    def __lowercase   (   self    :  Dict    ,						lowerCamelCase    :  str		)   ->  List[str]:
      return self.sp_model.encode(lowerCamelCase    ,						out_type=lowerCamelCase		)

    def __lowercase   (   self    :  Any    ,						lowerCamelCase    :  str		)   ->  int:
      if token in self.decoder:
        return self.decoder[token]
      elif token in self.added_tokens_decoder:
        return self.added_tokens_decoder[token]
      lowerCAmelCase_			:      Union[str, Any]			=   self.sp_model.piece_to_id(lowerCamelCase		)
      return sp_id + self.offset

    def __lowercase   (   self    :  Any    ,						lowerCamelCase    :  int		)   ->  str:
      if index in self.encoder:
        return self.encoder[index]
      elif index in self.added_tokens_encoder:
        return self.added_tokens_encoder[index]
      else:
        lowerCAmelCase_			:      List[Any]			=   self.sp_model.IdToPiece(index - self.offset		)
      return token

    def __lowercase   (   self    :  Any    ,						lowerCamelCase    :  Optional[Any]		)   ->  Optional[Any]:
      lowerCAmelCase_			:      int			=   []
      lowerCAmelCase_			:      Dict			=   """"""
      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(lowerCamelCase		) + token
          lowerCAmelCase_			:      Union[str, Any]			=   []
        else:
          current_sub_tokens.append(lowerCamelCase		)
      out_string += self.sp_model.decode(lowerCamelCase		)
      return out_string.strip()

    def __lowercase   (   self    :  Union[str, Any]    ,						lowerCamelCase    :  int=False		)   ->  Optional[int]:
      return 1

    def __lowercase   (   self    :  List[Any]    ,						lowerCamelCase    :  Optional[Any]		)   ->  List[str]:
      lowerCAmelCase_			:      Union[str, Any]			=   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 __lowercase   (   self    :  List[Any]    ,						lowerCamelCase    :  List    ,						lowerCamelCase    :  Optional[List] = None    ,						lowerCamelCase    :  bool = False		)   ->  List[int]:
      if already_has_special_tokens:
        return self._special_token_mask(lowerCamelCase		)
      elif token_ids_a is None:
        return self._special_token_mask(lowerCamelCase		) + [1]
      else:
        return self._special_token_mask(token_ids_a + token_ids_a		) + [1]

    def __lowercase   (   self    :  Optional[int]    ,						lowerCamelCase    :  Union[str, Any]    ,						lowerCamelCase    :  List[Any]=None		)   ->  List[int]:
      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 __lowercase   (   self    :  Tuple    ,						lowerCamelCase    :  str    ,						lowerCamelCase    :  Optional[str] = None		)   ->  Tuple[str]:
      if not os.path.isdir(lowerCamelCase		):
        logger.error(F'Vocabulary path ({save_directory}) should be a directory'		)
        return
      lowerCAmelCase_			:      Dict			=   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		) and os.path.isfile(self.vocab_file		):
        copyfile(self.vocab_file    ,						lowerCamelCase		)
      elif not os.path.isfile(self.vocab_file		):
        with open(lowerCamelCase    ,						"""wb"""		) as fi:
          lowerCAmelCase_			:      str			=   self.sp_model.serialized_model_proto()
          fi.write(lowerCamelCase		)

      return (out_vocab_file,)







'''simple docstring'''






from math import ceil







def 				UpperCamelCase_			(    A__					:   int = 10_01					):
  '''simple docstring'''





  lowerCAmelCase_			:      List[Any]			=   1

  for i in range(1							,    int(ceil(n / 2.0					)					)					):
    lowerCAmelCase_			:      int			=   2 * i + 1
    lowerCAmelCase_			:      Tuple			=   2 * i
    lowerCAmelCase_			:      Tuple			=   total + 4 * odd**2 - 6 * even

  return total


if __name__ == "__main__":
  import sys

  if len(sys.argv) == 1:
    print(solution())
  else:
    try:
      __A					:  str											=      int(sys.argv[1])
      print(solution(n))
    except ValueError:
      print("Invalid entry - please enter a number")



