
import os
import unittest

from transformers.models.bartpho.tokenization_bartpho import VOCAB_FILES_NAMES, BartphoTokenizer
from transformers.testing_utils import get_tests_dir

from ...test_tokenization_common import TokenizerTesterMixin


lowercase  : Union[str, Any]						   =							get_tests_dir("""fixtures/test_sentencepiece_bpe.model""")

class __snake_case		(				lowerCAmelCase ,     unittest.TestCase					):
    _a		:						Any=    BartphoTokenizer
    _a		:						Optional[Any]=    False
    _a		:						Any=    True
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           super().setUp()

           lowercase							:					Union[str, Any]	     =				["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]
           lowercase							:					Dict	     =				dict(zip(snake_case		,range(len(snake_case				)				)				)				)
           lowercase							:					Tuple	     =				{"""unk_token""": """<unk>"""}

           lowercase							:					Dict	     =				os.path.join(self.tmpdirname		,VOCAB_FILES_NAMES["""monolingual_vocab_file"""]				)
           with open(self.monolingual_vocab_file		,"""w"""		,encoding="""utf-8"""				) as fp:
                  for token in vocab_tokens:
                         fp.write(f"{token} {vocab_tokens[token]}\n"				)

           lowercase							:					Any	     =				BartphoTokenizer(snake_case		,self.monolingual_vocab_file		,**self.special_tokens_map				)
           tokenizer.save_pretrained(self.tmpdirname				)
    def 				_SCREAMING_SNAKE_CASE	(  self		,**snake_case				):



           '''simple docstring'''







           kwargs.update(self.special_tokens_map				)
           return BartphoTokenizer.from_pretrained(self.tmpdirname		,**snake_case				)
    def 				_SCREAMING_SNAKE_CASE	(  self		,snake_case				):



           '''simple docstring'''







           lowercase							:					List[Any]	     =				"""This is a là test"""
           lowercase							:					Optional[int]	     =				"""This is a<unk><unk> test"""
           return input_text, output_text
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           lowercase							:					Tuple	     =				BartphoTokenizer(snake_case		,self.monolingual_vocab_file		,**self.special_tokens_map				)
           lowercase							:					Optional[int]	     =				"""This is a là test"""
           lowercase							:					Union[str, Any]	     =				"""▁This ▁is ▁a ▁l à ▁t est""".split()
           lowercase							:					Optional[Any]	     =				tokenizer.tokenize(snake_case				)
           self.assertListEqual(snake_case		,snake_case				)

           lowercase							:					int	     =				tokens + [tokenizer.unk_token]
           lowercase							:					Optional[int]	     =				[4, 5, 6, 3, 3, 7, 8, 3]
           self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case				)		,snake_case				)


from collections.abc import Generator







def 						_snake_case(  )			->   Generator[int, None, None]:
       lowercase     ,      lowercase							:					List[str]	     =				0, 1
       while True:
              lowercase     ,      lowercase							:					Optional[int]	     =				b, a + b
              yield b







def 						_snake_case(  SCREAMING_SNAKE_CASE__ = 1_000    )			->   int:
       lowercase							:					List[Any]	     =				1
       lowercase							:					Tuple	     =				fibonacci_generator()
       while len(str(next(SCREAMING_SNAKE_CASE__    )    )    ) < n:
              answer += 1
       return answer + 1


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