






'''simple docstring'''



import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
@require_tokenizers
class 				__SCREAMING_SNAKE_CASE							(				UpperCAmelCase_   ,   unittest.TestCase  ):
      __a	       =RoCBertTokenizer
      __a	       =None
      __a	       =False
      __a	       =True
      __a	       =filter_non_english




      def 			__UpperCamelCase				(	self   )				->Union[str, Any]:



         '''simple docstring'''
         super().setUp()

         __a					  =     ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """你""", """好""", """是""", """谁""", """a""", """b""", """c""", """d"""]
         __a					  =     {}
         __a					  =     {}
         for i, value in enumerate(SCREAMING_SNAKE_CASE_   ):
            __a					  =     i
            __a					  =     i
         __a					  =     os.path.join(self.tmpdirname			, VOCAB_FILES_NAMES['vocab_file']   )
         __a					  =     os.path.join(self.tmpdirname			, VOCAB_FILES_NAMES['word_shape_file']   )
         __a					  =     os.path.join(self.tmpdirname			, VOCAB_FILES_NAMES['word_pronunciation_file']   )
         with open(self.vocab_file			, 'w'			, encoding='utf-8'   ) as vocab_writer:
            vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]   )   )
         with open(self.word_shape_file			, 'w'			, encoding='utf-8'   ) as word_shape_writer:
            json.dump(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_			, ensure_ascii=SCREAMING_SNAKE_CASE_   )
         with open(self.word_pronunciation_file			, 'w'			, encoding='utf-8'   ) as word_pronunciation_writer:
            json.dump(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_			, ensure_ascii=SCREAMING_SNAKE_CASE_   )




      def 			__UpperCamelCase				(	self   )				->str:



         '''simple docstring'''
         __a					  =     self.tokenizer_class(self.vocab_file			, self.word_shape_file			, self.word_pronunciation_file   )

         __a					  =     tokenizer.tokenize('你好[SEP]你是谁'   )
         self.assertListEqual(SCREAMING_SNAKE_CASE_			, ['你', '好', '[SEP]', '你', '是', '谁']   )
         self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_   )			, [5, 6, 2, 5, 7, 8]   )
         self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(SCREAMING_SNAKE_CASE_   )			, [5, 6, 2, 5, 7, 8]   )
         self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(SCREAMING_SNAKE_CASE_   )			, [5, 6, 2, 5, 7, 8]   )




      def 			__UpperCamelCase				(	self   )				->int:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer()

         self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'   )			, ['ah', '\u535A', '\u63A8', 'zz']   )




      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '   )			, ['hello', '!', 'how', 'are', 'you', '?']   )
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )			, ['hello']   )




      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_			, strip_accents=SCREAMING_SNAKE_CASE_   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )			, ['hällo', '!', 'how', 'are', 'you', '?']   )
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )			, ['h\u00E9llo']   )




      def 			__UpperCamelCase				(	self   )				->int:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_			, strip_accents=SCREAMING_SNAKE_CASE_   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )			, ['hallo', '!', 'how', 'are', 'you', '?']   )
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )			, ['hello']   )




      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )			, ['hallo', '!', 'how', 'are', 'you', '?']   )
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )			, ['hello']   )




      def 			__UpperCamelCase				(	self   )				->int:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '   )			, ['HeLLo', '!', 'how', 'Are', 'yoU', '?']   )




      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_			, strip_accents=SCREAMING_SNAKE_CASE_   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )			, ['HäLLo', '!', 'how', 'Are', 'yoU', '?']   )




      def 			__UpperCamelCase				(	self   )				->List[Any]:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_			, strip_accents=SCREAMING_SNAKE_CASE_   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )			, ['HaLLo', '!', 'how', 'Are', 'yoU', '?']   )




      def 			__UpperCamelCase				(	self   )				->str:



         '''simple docstring'''
         __a					  =     RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_			, never_split=['[UNK]']   )

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'   )			, ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']   )




      def 			__UpperCamelCase				(	self   )				->Optional[int]:



         '''simple docstring'''
         __a					  =     ["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""]

         __a					  =     {}
         for i, token in enumerate(SCREAMING_SNAKE_CASE_   ):
            __a					  =     i
         __a					  =     RoCBertWordpieceTokenizer(vocab=SCREAMING_SNAKE_CASE_			, unk_token='[UNK]'   )

         self.assertListEqual(tokenizer.tokenize(''   )			, []   )

         self.assertListEqual(tokenizer.tokenize('unwanted running'   )			, ['un', '##want', '##ed', 'runn', '##ing']   )

         self.assertListEqual(tokenizer.tokenize('unwantedX running'   )			, ['[UNK]', 'runn', '##ing']   )




      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         self.assertTrue(_is_whitespace(' '   )   )
         self.assertTrue(_is_whitespace('\t'   )   )
         self.assertTrue(_is_whitespace('\r'   )   )
         self.assertTrue(_is_whitespace('\n'   )   )
         self.assertTrue(_is_whitespace('\u00A0'   )   )

         self.assertFalse(_is_whitespace('A'   )   )
         self.assertFalse(_is_whitespace('-'   )   )




      def 			__UpperCamelCase				(	self   )				->Union[str, Any]:



         '''simple docstring'''
         self.assertTrue(_is_control('\u0005'   )   )

         self.assertFalse(_is_control('A'   )   )
         self.assertFalse(_is_control(' '   )   )
         self.assertFalse(_is_control('\t'   )   )
         self.assertFalse(_is_control('\r'   )   )




      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         self.assertTrue(_is_punctuation('-'   )   )
         self.assertTrue(_is_punctuation('$'   )   )
         self.assertTrue(_is_punctuation('`'   )   )
         self.assertTrue(_is_punctuation('.'   )   )

         self.assertFalse(_is_punctuation('A'   )   )
         self.assertFalse(_is_punctuation(' '   )   )




      def 			__UpperCamelCase				(	self   )				->Optional[int]:



         '''simple docstring'''
         __a					  =     self.get_tokenizer()

         # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
         self.assertListEqual([tokenizer.tokenize(SCREAMING_SNAKE_CASE_   ) for t in ['Test', '\xad', 'test']]			, [['[UNK]'], [], ['[UNK]']]   )

         if self.test_rust_tokenizer:
            __a					  =     self.get_rust_tokenizer()
            self.assertListEqual(
                [rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_   ) for t in ['Test', '\xad', 'test']]			, [['[UNK]'], [], ['[UNK]']]   )




      def 			__UpperCamelCase				(	self   )				->List[Any]:



         '''simple docstring'''




         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
               __a					  =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_			, **SCREAMING_SNAKE_CASE_   )

               __a					  =     F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
               __a					  =     tokenizer_r.encode_plus(
                   SCREAMING_SNAKE_CASE_			, return_attention_mask=SCREAMING_SNAKE_CASE_			, return_token_type_ids=SCREAMING_SNAKE_CASE_			, return_offsets_mapping=SCREAMING_SNAKE_CASE_			, add_special_tokens=SCREAMING_SNAKE_CASE_			, )

               __a					  =     tokenizer_r.do_lower_case if hasattr(SCREAMING_SNAKE_CASE_			, 'do_lower_case'   ) else False
               __a					  =     (
                   [
                       ((0, 0), tokenizer_r.cls_token),
                       ((0, 1), """A"""),
                       ((1, 2), ""","""),
                       ((3, 5), """na"""),
                       ((5, 6), """##ï"""),
                       ((6, 8), """##ve"""),
                       ((9, 15), tokenizer_r.mask_token),
                       ((16, 21), """Allen"""),
                       ((21, 23), """##NL"""),
                       ((23, 24), """##P"""),
                       ((25, 33), """sentence"""),
                       ((33, 34), """."""),
                       ((0, 0), tokenizer_r.sep_token),
                   ]
                   if not do_lower_case
                   else [
                       ((0, 0), tokenizer_r.cls_token),
                       ((0, 1), """a"""),
                       ((1, 2), ""","""),
                       ((3, 8), """naive"""),
                       ((9, 15), tokenizer_r.mask_token),
                       ((16, 21), """allen"""),
                       ((21, 23), """##nl"""),
                       ((23, 24), """##p"""),
                       ((25, 33), """sentence"""),
                       ((33, 34), """."""),
                       ((0, 0), tokenizer_r.sep_token),
                   ]
               )

               self.assertEqual(
                   [e[1] for e in expected_results]			, tokenizer_r.convert_ids_to_tokens(tokens['input_ids']   )   )
               self.assertEqual([e[0] for e in expected_results]			, tokens['offset_mapping']   )




      def 			__UpperCamelCase				(	self   )				->Any:



         '''simple docstring'''
         __a					  =     ["""的""", """人""", """有"""]
         __a					  =     """""".join(SCREAMING_SNAKE_CASE_   )
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
               __a					  =     True
               __a					  =     self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_			, **SCREAMING_SNAKE_CASE_   )
               __a					  =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_			, **SCREAMING_SNAKE_CASE_   )

               __a					  =     tokenizer_p.encode(SCREAMING_SNAKE_CASE_			, add_special_tokens=SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer_r.encode(SCREAMING_SNAKE_CASE_			, add_special_tokens=SCREAMING_SNAKE_CASE_   )

               __a					  =     tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_   )

               # it is expected that each Chinese character is not preceded by "##"
               self.assertListEqual(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_   )
               self.assertListEqual(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_   )

               __a					  =     False
               __a					  =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_			, **SCREAMING_SNAKE_CASE_   )
               __a					  =     self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_			, **SCREAMING_SNAKE_CASE_   )

               __a					  =     tokenizer_r.encode(SCREAMING_SNAKE_CASE_			, add_special_tokens=SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer_p.encode(SCREAMING_SNAKE_CASE_			, add_special_tokens=SCREAMING_SNAKE_CASE_   )

               __a					  =     tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_   )

               # it is expected that only the first Chinese character is not preceded by "##".
               __a					  =     [
                   F"""##{token}""" if idx != 0 else token for idx, token in enumerate(SCREAMING_SNAKE_CASE_   )
               ]
               self.assertListEqual(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_   )
               self.assertListEqual(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_   )




      @slow
      def 			__UpperCamelCase				(	self   )				->Optional[int]:



         '''simple docstring'''
         __a					  =     self.tokenizer_class(self.vocab_file			, self.word_shape_file			, self.word_pronunciation_file   )

         __a					  =     tokenizer.encode('你好'			, add_special_tokens=SCREAMING_SNAKE_CASE_   )
         __a					  =     tokenizer.encode('你是谁'			, add_special_tokens=SCREAMING_SNAKE_CASE_   )

         __a					  =     tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_   )
         __a					  =     tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_   )

         assert encoded_sentence == [1] + text + [2]
         assert encoded_pair == [1] + text + [2] + text_a + [2]






      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         __a					  =     self.get_tokenizers(do_lower_case=SCREAMING_SNAKE_CASE_   )
         for tokenizer in tokenizers:
            with self.subTest(F"""{tokenizer.__class__.__name__}"""   ):
               __a					  =     """你好，你是谁"""
               __a					  =     tokenizer.tokenize(SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer.convert_tokens_to_shape_ids(SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer.convert_tokens_to_pronunciation_ids(SCREAMING_SNAKE_CASE_   )
               __a					  =     tokenizer.prepare_for_model(
                   SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_			, add_special_tokens=SCREAMING_SNAKE_CASE_   )

               __a					  =     tokenizer.encode_plus(SCREAMING_SNAKE_CASE_			, add_special_tokens=SCREAMING_SNAKE_CASE_   )

               self.assertEqual(SCREAMING_SNAKE_CASE_			, SCREAMING_SNAKE_CASE_   )

def 		UpperCamelCase						(   lowercase_ )		->						int:


  '''simple docstring'''






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

    return sequence[n]

def 		UpperCamelCase						(   lowercase_ )		->						int:


  '''simple docstring'''






  lowercase__	: Optional[Any]     		=   0
  lowercase__	: Dict     		=   2

  while digits < n:
    index += 1
    lowercase__	: str     		=   len(str(fibonacci(lowercase_ ) ) )

  return index

def 		UpperCamelCase						(   lowercase_ = 10_00 )		->						int:


  '''simple docstring'''






  return fibonacci_digits_index(lowercase_ )


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






