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

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
      from .tokenization_ta import TaTokenizer
else:
      A   :     Union[str, Any]       =				None


A   :     Any       =				logging.get_logger(__name__)

A   :     Tuple       =				{"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"}

A   :     List[Any]       =				{
    "vocab_file": {
        "t5-small": "https://huggingface.co/t5-small/resolve/main/spiece.model",
        "t5-base": "https://huggingface.co/t5-base/resolve/main/spiece.model",
        "t5-large": "https://huggingface.co/t5-large/resolve/main/spiece.model",
        "t5-3b": "https://huggingface.co/t5-3b/resolve/main/spiece.model",
        "t5-11b": "https://huggingface.co/t5-11b/resolve/main/spiece.model",
    },
    "tokenizer_file": {
        "t5-small": "https://huggingface.co/t5-small/resolve/main/tokenizer.json",
        "t5-base": "https://huggingface.co/t5-base/resolve/main/tokenizer.json",
        "t5-large": "https://huggingface.co/t5-large/resolve/main/tokenizer.json",
        "t5-3b": "https://huggingface.co/t5-3b/resolve/main/tokenizer.json",
        "t5-11b": "https://huggingface.co/t5-11b/resolve/main/tokenizer.json",
    },
}


# TODO(PVP) - this should be removed in Transformers v5
A   :     Optional[Any]       =				{
    "t5-small": 5_12,
    "t5-base": 5_12,
    "t5-large": 5_12,
    "t5-3b": 5_12,
    "t5-11b": 5_12,
}


class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  VOCAB_FILES_NAMES
  lowerCamelCase__   =  PRETRAINED_VOCAB_FILES_MAP
  lowerCamelCase__   =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  lowerCamelCase__   =  ['''input_ids''', '''attention_mask''']
  lowerCamelCase__   =  TaTokenizer

  lowerCamelCase__   =  []







  def __init__(							self       :				int     ,   __magic_name__       :				Optional[int]=None     ,   __magic_name__       :				int=None     ,   __magic_name__       :				Optional[int]="</s>"     ,   __magic_name__       :				int="<unk>"     ,   __magic_name__       :				List[Any]="<pad>"     ,   __magic_name__       :				Optional[Any]=100     ,   __magic_name__       :				Tuple=None     ,   **__magic_name__       :				Optional[Any]     ,   )     ->		List[str]:
        # Add extra_ids to the special token list
        if extra_ids > 0 and additional_special_tokens is None:
              SCREAMING_SNAKE_CASE_      =     [F'''<extra_id_{i}>''' for i in range(__magic_name__      )]
        elif extra_ids > 0 and additional_special_tokens is not None:
              # Check that we have the right number of extra special tokens
              SCREAMING_SNAKE_CASE_      =     len(set(filter(lambda __magic_name__      : bool("extra_id_" in str(__magic_name__      )      )     ,   __magic_name__      )      )      )
              if extra_tokens != extra_ids:
                    raise ValueError(
                        F'''Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are'''
                        " provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids"
                        " tokens"      )

        super().__init__(
            __magic_name__     ,   tokenizer_file=__magic_name__     ,   eos_token=__magic_name__     ,   unk_token=__magic_name__     ,   pad_token=__magic_name__     ,   extra_ids=__magic_name__     ,   additional_special_tokens=__magic_name__     ,   **__magic_name__     ,   )

        SCREAMING_SNAKE_CASE_      =     vocab_file
        SCREAMING_SNAKE_CASE_      =     False if not self.vocab_file else True
        SCREAMING_SNAKE_CASE_      =     extra_ids







  @staticmethod
  def       __A   (							__magic_name__       :				Tuple     ,   __magic_name__       :				Union[str, Any]     ,   __magic_name__       :				Tuple      )     ->		List[str]:
        if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes:
              SCREAMING_SNAKE_CASE_      =     TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path]
              if init_max_model_length is not None and init_max_model_length != max_model_length:
                    return init_max_model_length
              elif init_max_model_length is None:
                    warnings.warn(
                        "This tokenizer was incorrectly instantiated with a model max length of"
                        F''' {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this'''
                        " behavior is kept to avoid breaking backwards compatibility when padding/encoding with"
                        " `truncation is True`.\n- Be aware that you SHOULD NOT rely on"
                        F''' {pretrained_model_name_or_path} automatically truncating your input to'''
                        F''' {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences'''
                        F''' longer than {deprecated_max_model_length} you can either instantiate this tokenizer with'''
                        " `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please"
                        " instantiate this tokenizer with `model_max_length` set to your preferred value."     ,   __magic_name__     ,   )

        return max_model_length







  def       __A   (							self       :				Tuple     ,   __magic_name__       :				str     ,   __magic_name__       :				Optional[str] = None      )     ->		Tuple[str]:
        if not self.can_save_slow_tokenizer:
              raise ValueError(
                  "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
                  "tokenizer."      )

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

        if os.path.abspath(self.vocab_file      ) != os.path.abspath(__magic_name__      ):
              copyfile(self.vocab_file     ,   __magic_name__      )
              logger.info(F'''Copy vocab file to {out_vocab_file}'''      )

        return (out_vocab_file,)







  def       __A   (							self       :				Tuple     ,   __magic_name__       :				List[int]     ,   __magic_name__       :				Optional[List[int]] = None      )     ->		List[int]:
        SCREAMING_SNAKE_CASE_      =     token_ids_a + [self.eos_token_id]
        if token_ids_a is None:
              return self.prefix_tokens + token_ids_a
        else:
              SCREAMING_SNAKE_CASE_      =     token_ids_a + [self.eos_token_id]
              return self.prefix_tokens + token_ids_a + token_ids_a







  def       __A   (							self       :				Optional[Any]     ,   __magic_name__       :				List[int]     ,   __magic_name__       :				Optional[List[int]] = None      )     ->		List[int]:
        SCREAMING_SNAKE_CASE_      =     [self.eos_token_id]

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







  def       __A   (							self       :				Union[str, Any]      )     ->		List[str]:
        return list(
            set(filter(lambda __magic_name__      : bool(re.search(r"<extra_id_\d+>"     ,   __magic_name__      )      ) is not None     ,   self.additional_special_tokens      )      )      )







  def       __A   (							self       :				Union[str, Any]      )     ->		Any:
        return [self.convert_tokens_to_ids(__magic_name__      ) for token in self.get_sentinel_tokens()]



def    a__       (						__UpperCamelCase ):
      if n == 1 or not isinstance(__UpperCamelCase   ,					__UpperCamelCase ):
            return 0
      elif n == 2:
            return 1
      else:
            SCREAMING_SNAKE_CASE_      =     [0, 1]
            for i in range(2   ,					n + 1 ):
                  sequence.append(sequence[i - 1] + sequence[i - 2] )

            return sequence[n]


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     2

      while digits < n:
            index += 1
            SCREAMING_SNAKE_CASE_      =     len(str(fibonacci(__UpperCamelCase ) ) )

      return index


def    a__       (						__UpperCamelCase = 1_0_0_0 ):
      return fibonacci_digits_index(__UpperCamelCase )


if __name__ == "__main__":
      print(solution(int(str(input()).strip())))


