






'''simple docstring'''



import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_electra import ElectraTokenizer


SCREAMING_SNAKE_CASE							=						{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

SCREAMING_SNAKE_CASE							=						{
    'vocab_file': {
        'google/electra-small-generator': (
            'https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt'
        ),
        'google/electra-base-generator': 'https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt',
        'google/electra-large-generator': (
            'https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt'
        ),
        'google/electra-small-discriminator': (
            'https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt'
        ),
        'google/electra-base-discriminator': (
            'https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt'
        ),
        'google/electra-large-discriminator': (
            'https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'google/electra-small-generator': (
            'https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json'
        ),
        'google/electra-base-generator': (
            'https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json'
        ),
        'google/electra-large-generator': (
            'https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json'
        ),
        'google/electra-small-discriminator': (
            'https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json'
        ),
        'google/electra-base-discriminator': (
            'https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json'
        ),
        'google/electra-large-discriminator': (
            'https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json'
        ),
    },
}

SCREAMING_SNAKE_CASE							=						{
    'google/electra-small-generator': 512,
    'google/electra-base-generator': 512,
    'google/electra-large-generator': 512,
    'google/electra-small-discriminator': 512,
    'google/electra-base-discriminator': 512,
    'google/electra-large-discriminator': 512,
}

SCREAMING_SNAKE_CASE							=						{
    'google/electra-small-generator': {'do_lower_case': True},
    'google/electra-base-generator': {'do_lower_case': True},
    'google/electra-large-generator': {'do_lower_case': True},
    'google/electra-small-discriminator': {'do_lower_case': True},
    'google/electra-base-discriminator': {'do_lower_case': True},
    'google/electra-large-discriminator': {'do_lower_case': True},
}
class UpperCAmelCase_       (     __A					):




      """simple docstring"""




      UpperCamelCase_             =      VOCAB_FILES_NAMES
      UpperCamelCase_             =      PRETRAINED_VOCAB_FILES_MAP
      UpperCamelCase_             =      PRETRAINED_INIT_CONFIGURATION
      UpperCamelCase_             =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      UpperCamelCase_             =      ElectraTokenizer






      def __init__(			self      :		Optional[int]  ,   UpperCAmelCase      :		Any=None  ,   UpperCAmelCase      :		str=None  ,   UpperCAmelCase      :		List[Any]=True  ,   UpperCAmelCase      :		str="[UNK]"  ,   UpperCAmelCase      :		Dict="[SEP]"  ,   UpperCAmelCase      :		List[Any]="[PAD]"  ,   UpperCAmelCase      :		List[Any]="[CLS]"  ,   UpperCAmelCase      :		Union[str, Any]="[MASK]"  ,   UpperCAmelCase      :		Optional[Any]=True  ,   UpperCAmelCase      :		int=None  ,   **UpperCAmelCase      :		Dict  ,   )	->	Optional[int]:


       '''simple docstring'''

       super().__init__(
           UpperCAmelCase  ,   tokenizer_file=UpperCAmelCase  ,   do_lower_case=UpperCAmelCase  ,   unk_token=UpperCAmelCase  ,   sep_token=UpperCAmelCase  ,   pad_token=UpperCAmelCase  ,   cls_token=UpperCAmelCase  ,   mask_token=UpperCAmelCase  ,   tokenize_chinese_chars=UpperCAmelCase  ,   strip_accents=UpperCAmelCase  ,   **UpperCAmelCase  ,   )

       lowercase       : List[Any]						=json.loads(self.backend_tokenizer.normalizer.__getstate__()		)
       if (
           normalizer_state.get('''lowercase'''  ,   UpperCAmelCase		) != do_lower_case
           or normalizer_state.get('''strip_accents'''  ,   UpperCAmelCase		) != strip_accents
           or normalizer_state.get('''handle_chinese_chars'''  ,   UpperCAmelCase		) != tokenize_chinese_chars
       ):
        lowercase       : Dict						=getattr(UpperCAmelCase  ,   normalizer_state.pop('''type'''		)		)
        lowercase       : Optional[Any]						=do_lower_case
        lowercase       : int						=strip_accents
        lowercase       : Tuple						=tokenize_chinese_chars
        lowercase       : Union[str, Any]						=normalizer_class(**UpperCAmelCase		)

       lowercase       : List[str]						=do_lower_case






      def 					A__   (			self      :		List[Any]  ,   UpperCAmelCase      :		Optional[Any]  ,   UpperCAmelCase      :		Tuple=None		)	->	Union[str, Any]:


       '''simple docstring'''

       lowercase       : Optional[Any]						=[self.cls_token_id] + token_ids_a + [self.sep_token_id]

       if token_ids_a:
        output += token_ids_a + [self.sep_token_id]

       return output






      def 					A__   (			self      :		int  ,   UpperCAmelCase      :		List[int]  ,   UpperCAmelCase      :		Optional[List[int]] = None		)	->	List[int]:


       '''simple docstring'''

       lowercase       : Dict						=[self.sep_token_id]
       lowercase       : Tuple						=[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		) * [0] + len(token_ids_a + sep		) * [1]






      def 					A__   (			self      :		int  ,   UpperCAmelCase      :		str  ,   UpperCAmelCase      :		Optional[str] = None		)	->	Tuple[str]:


       '''simple docstring'''

       lowercase       : Optional[int]						=self._tokenizer.model.save(UpperCAmelCase  ,   name=UpperCAmelCase		)
       return tuple(UpperCAmelCase		)











'''simple docstring'''



def 				lowercase_					(     __A			:							int      )							->   int:



 """simple docstring"""




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

  return sequence[n]


def 				lowercase_					(     __A			:							int      )							->   int:



 """simple docstring"""




 lowercase       : List[str]						=0
 lowercase       : str						=2

 while digits < n:
  index += 1
  lowercase       : int						=len(str(fibonacci(__A      )      )      )

 return index


def 				lowercase_					(     __A			:							int = 1_0_0_0      )							->   int:



 """simple docstring"""




 return fibonacci_digits_index(__A      )


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



