

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

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


if is_sentencepiece_available():
       from .tokenization_camembert import CamembertTokenizer
else:
       A_		:      Union[str, Any]					    = None


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

A_		:      List[str]					    = {'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'}

A_		:      Tuple					    = {
    'vocab_file': {
        'camembert-base': 'https://huggingface.co/camembert-base/resolve/main/sentencepiece.bpe.model',
    },
    'tokenizer_file': {
        'camembert-base': 'https://huggingface.co/camembert-base/resolve/main/tokenizer.json',
    },
}

A_		:      Dict					    = {
    'camembert-base': 512,
}

A_		:      Optional[Any]					    = '▁'
class        A_ (   UpperCAmelCase_    ):


    '''simple docstring'''






    a__  				=							VOCAB_FILES_NAMES
    a__  				=							PRETRAINED_VOCAB_FILES_MAP
    a__  				=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    a__  				=							["input_ids", "attention_mask"]
    a__  				=							CamembertTokenizer


    def __init__(self  ,   lowercase__=None  ,   lowercase__=None  ,   lowercase__="<s>"  ,   lowercase__="</s>"  ,   lowercase__="</s>"  ,   lowercase__="<s>"  ,   lowercase__="<unk>"  ,   lowercase__="<pad>"  ,   lowercase__="<mask>"  ,   lowercase__=["<s>NOTUSED", "</s>NOTUSED"]  ,   **lowercase__  ,   )  ->   Tuple:
        __UpperCAmelCase					       =      AddedToken(__a  ,   lstrip=__a  ,   rstrip=__a	) if isinstance(__a  ,   __a	) else mask_token

        super().__init__(
            __a  ,   tokenizer_file=__a  ,   bos_token=__a  ,   eos_token=__a  ,   sep_token=__a  ,   cls_token=__a  ,   unk_token=__a  ,   pad_token=__a  ,   mask_token=__a  ,   additional_special_tokens=__a  ,   **__a  ,   )

        __UpperCAmelCase					       =      vocab_file
        __UpperCAmelCase					       =      False if not self.vocab_file else True


    def   lowerCAmelCase_    (self  ,   lowercase__  ,   lowercase__ = None	)  ->   int:



        if token_ids_a is None:
            return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
        __UpperCAmelCase					       =      [self.cls_token_id]
        __UpperCAmelCase					       =      [self.sep_token_id]
        return cls + token_ids_a + sep + sep + token_ids_a + sep


    def   lowerCAmelCase_    (self  ,   lowercase__  ,   lowercase__ = None	)  ->   List[str]:
        __UpperCAmelCase					       =      [self.sep_token_id]
        __UpperCAmelCase					       =      [self.cls_token_id]

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






    def   lowerCAmelCase_    (self  ,   lowercase__  ,   lowercase__ = None	)  ->   Dict:



        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(__a	):
            logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''	)
            return
        __UpperCAmelCase					       =      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	):
            copyfile(self.vocab_file  ,   __a	)

        return (out_vocab_file,)









def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



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

            return sequence[n]

def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		0
      lowerCamelCase             =		2

      while digits < n:
            index += 1
            lowerCamelCase             =		len(str(fibonacci(UpperCAmelCase__			)			)			)

      return index

def      __lowercase(						UpperCAmelCase__ = 1000			):


      """simple docstring"""



      return fibonacci_digits_index(UpperCAmelCase__			)


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