



'''simple docstring'''

import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_convbert import ConvBertTokenizer


snake_case_      =  logging.get_logger(__name__)

snake_case_      =  {"""vocab_file""": """vocab.txt"""}

snake_case_      =  {
    """vocab_file""": {
        """YituTech/conv-bert-base""": """https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt""",
        """YituTech/conv-bert-medium-small""": (
            """https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt"""
        ),
        """YituTech/conv-bert-small""": """https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt""",
    }
}

snake_case_      =  {
    """YituTech/conv-bert-base""": 512,
    """YituTech/conv-bert-medium-small""": 512,
    """YituTech/conv-bert-small""": 512,
}


snake_case_      =  {
    """YituTech/conv-bert-base""": {"""do_lower_case""": True},
    """YituTech/conv-bert-medium-small""": {"""do_lower_case""": True},
    """YituTech/conv-bert-small""": {"""do_lower_case""": True},
}


class 						a__  (					a__						):
	__magic_name__		:     List[Any]						     =  VOCAB_FILES_NAMES
	__magic_name__		:     Optional[Any]						     =  PRETRAINED_VOCAB_FILES_MAP
	__magic_name__		:     Optional[int]						     =  PRETRAINED_INIT_CONFIGURATION
	__magic_name__		:     List[str]						     =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	__magic_name__		:     Union[str, Any]						     =  ConvBertTokenizer


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

					"""simple docstring"""

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

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

					SCREAMING_SNAKE_CASE	:    Any          =			do_lower_case


	def 					lowercase__	(self			:			Optional[int],       __UpperCAmelCase			:			Union[str, Any],       __UpperCAmelCase			:			Optional[int]=None   )  ->      Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    List[str]          =			[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 					lowercase__	(self			:			Any,       __UpperCAmelCase			:			List[Any],       __UpperCAmelCase			:			Union[str, Any] = None   )  ->      List[int]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			[self.sep_token_id]
					SCREAMING_SNAKE_CASE	:    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 					lowercase__	(self			:			List[Any],       __UpperCAmelCase			:			str,       __UpperCAmelCase			:			Union[str, Any] = None   )  ->      Tuple[str]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Any          =			self._tokenizer.model.save(lowerCamelCase_,       name=lowerCamelCase_   )
					return tuple(lowerCamelCase_   )








'''simple docstring'''






def    _snake_case  (	A			)		->       int:
							if n == 1 or not isinstance(A					,       A			):
														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    _snake_case  (	A			)		->       int:
							lowerCAmelCase__			  =      0
							lowerCAmelCase__			  =      2

							while digits < n:
														index += 1
														lowerCAmelCase__			  =      len(str(fibonacci(A			)			)			)

							return index


def    _snake_case  (	A = 1000			)		->       int:
							return fibonacci_digits_index(A			)


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