"""simple docstring"""






import unittest

from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__A			   = get_tests_dir("fixtures/test_sentencepiece.model")


@require_sentencepiece
@require_tokenizers
class     UpperCAmelCase						(_UpperCAmelCase    ,unittest.TestCase  ):



    """simple docstring"""

    _UpperCAmelCase	:Any						    = ReformerTokenizer
    _UpperCAmelCase	:Optional[Any]						    = ReformerTokenizerFast
    _UpperCAmelCase	:Optional[int]						    = True
    _UpperCAmelCase	:str						    = False
    _UpperCAmelCase	:List[Any]						    = True






    def _snake_case			(   self							):
       super().setUp()

       lowercase__:   int					=      ReformerTokenizer(_UpperCAmelCase    ,			keep_accents=_UpperCAmelCase							)
       tokenizer.save_pretrained(self.tmpdirname							)






    def _snake_case			(   self							):
       lowercase__:   Optional[Any]					=      '''<s>'''
       lowercase__:   List[str]					=      1

       self.assertEqual(self.get_tokenizer()._convert_token_to_id(_UpperCAmelCase							)    ,			_UpperCAmelCase							)
       self.assertEqual(self.get_tokenizer()._convert_id_to_token(_UpperCAmelCase							)    ,			_UpperCAmelCase							)






    def _snake_case			(   self							):
       lowercase__:   Dict					=      list(self.get_tokenizer().get_vocab().keys()							)

       self.assertEqual(vocab_keys[0]    ,			'''<unk>'''							)
       self.assertEqual(vocab_keys[1]    ,			'''<s>'''							)
       self.assertEqual(vocab_keys[-1]    ,			'''j'''							)
       self.assertEqual(len(_UpperCAmelCase							)    ,			1000							)






    def _snake_case			(   self							):
       self.assertEqual(self.get_tokenizer().vocab_size    ,			1000							)






    def _snake_case			(   self							):
       if not self.test_rust_tokenizer:
          return

       lowercase__:   Tuple					=      self.get_tokenizer()
       lowercase__:   Optional[int]					=      self.get_rust_tokenizer()

       lowercase__:   Any					=      '''I was born in 92000, and this is falsé.'''

       lowercase__:   List[Any]					=      tokenizer.tokenize(_UpperCAmelCase							)
       lowercase__:   Optional[Any]					=      rust_tokenizer.tokenize(_UpperCAmelCase							)
       self.assertListEqual(_UpperCAmelCase    ,			_UpperCAmelCase							)

       lowercase__:   Optional[int]					=      tokenizer.encode(_UpperCAmelCase    ,			add_special_tokens=_UpperCAmelCase							)
       lowercase__:   int					=      rust_tokenizer.encode(_UpperCAmelCase    ,			add_special_tokens=_UpperCAmelCase							)
       self.assertListEqual(_UpperCAmelCase    ,			_UpperCAmelCase							)

       lowercase__:   str					=      self.get_rust_tokenizer()
       lowercase__:   Dict					=      tokenizer.encode(_UpperCAmelCase							)
       lowercase__:   Union[str, Any]					=      rust_tokenizer.encode(_UpperCAmelCase							)
       self.assertListEqual(_UpperCAmelCase    ,			_UpperCAmelCase							)






    def _snake_case			(   self    ,			_UpperCAmelCase=15							):
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
             lowercase__:   str					=      self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase    ,			**_UpperCAmelCase							)

             # Simple input
             lowercase__:   List[Any]					=      '''This is a simple input'''
             lowercase__:   Any					=      ['''This is a simple input 1''', '''This is a simple input 2''']
             lowercase__:   Tuple					=      ('''This is a simple input''', '''This is a pair''')
             lowercase__:   List[str]					=      [
                 ('''This is a simple input 1''', '''This is a simple input 2'''),
                 ('''This is a simple pair 1''', '''This is a simple pair 2'''),
             ]

             # Simple input tests
             self.assertRaises(_UpperCAmelCase    ,			tokenizer_r.encode    ,			_UpperCAmelCase    ,			max_length=_UpperCAmelCase    ,			padding='''max_length'''							)

             # Simple input
             self.assertRaises(_UpperCAmelCase    ,			tokenizer_r.encode_plus    ,			_UpperCAmelCase    ,			max_length=_UpperCAmelCase    ,			padding='''max_length'''							)

             # Simple input
             self.assertRaises(
                 _UpperCAmelCase    ,			tokenizer_r.batch_encode_plus    ,			_UpperCAmelCase    ,			max_length=_UpperCAmelCase    ,			padding='''max_length'''    ,			)

             # Pair input
             self.assertRaises(_UpperCAmelCase    ,			tokenizer_r.encode    ,			_UpperCAmelCase    ,			max_length=_UpperCAmelCase    ,			padding='''max_length'''							)

             # Pair input
             self.assertRaises(_UpperCAmelCase    ,			tokenizer_r.encode_plus    ,			_UpperCAmelCase    ,			max_length=_UpperCAmelCase    ,			padding='''max_length'''							)

             # Pair input
             self.assertRaises(
                 _UpperCAmelCase    ,			tokenizer_r.batch_encode_plus    ,			_UpperCAmelCase    ,			max_length=_UpperCAmelCase    ,			padding='''max_length'''    ,			)






    def _snake_case			(   self							):
       pass






    def _snake_case			(   self							):
       lowercase__:   int					=      ReformerTokenizer(_UpperCAmelCase    ,			keep_accents=_UpperCAmelCase							)

       lowercase__:   str					=      tokenizer.tokenize('''This is a test'''							)
       self.assertListEqual(_UpperCAmelCase    ,			['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']							)

       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(_UpperCAmelCase							)    ,			[285, 46, 10, 170, 382]    ,			)

       lowercase__:   Dict					=      tokenizer.tokenize('''I was born in 92000, and this is falsé.'''							)
       self.assertListEqual(
           _UpperCAmelCase    ,			[
               SPIECE_UNDERLINE + '''I''',
               SPIECE_UNDERLINE + '''was''',
               SPIECE_UNDERLINE + '''b''',
               '''or''',
               '''n''',
               SPIECE_UNDERLINE + '''in''',
               SPIECE_UNDERLINE + '''''',
               '''9''',
               '''2''',
               '''0''',
               '''0''',
               '''0''',
               ''',''',
               SPIECE_UNDERLINE + '''and''',
               SPIECE_UNDERLINE + '''this''',
               SPIECE_UNDERLINE + '''is''',
               SPIECE_UNDERLINE + '''f''',
               '''al''',
               '''s''',
               '''é''',
               '''.''',
           ]    ,			)
       lowercase__:   List[str]					=      tokenizer.convert_tokens_to_ids(_UpperCAmelCase							)
       self.assertListEqual(
           _UpperCAmelCase    ,			[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]    ,			)

       lowercase__:   Tuple					=      tokenizer.convert_ids_to_tokens(_UpperCAmelCase							)
       self.assertListEqual(
           _UpperCAmelCase    ,			[
               SPIECE_UNDERLINE + '''I''',
               SPIECE_UNDERLINE + '''was''',
               SPIECE_UNDERLINE + '''b''',
               '''or''',
               '''n''',
               SPIECE_UNDERLINE + '''in''',
               SPIECE_UNDERLINE + '''''',
               '''<unk>''',
               '''2''',
               '''0''',
               '''0''',
               '''0''',
               ''',''',
               SPIECE_UNDERLINE + '''and''',
               SPIECE_UNDERLINE + '''this''',
               SPIECE_UNDERLINE + '''is''',
               SPIECE_UNDERLINE + '''f''',
               '''al''',
               '''s''',
               '''<unk>''',
               '''.''',
           ]    ,			)






    @cached_property
    def _snake_case			(   self							):
       return ReformerTokenizer.from_pretrained('''google/reformer-crime-and-punishment'''							)






    @slow
    def _snake_case			(   self							):
       lowercase__:   Optional[Any]					=      '''Hello World!'''
       lowercase__:   int					=      [126, 32, 262, 152, 38, 72, 287]

       self.assertListEqual(_UpperCAmelCase    ,			self.big_tokenizer.encode(_UpperCAmelCase							)							)






    @slow
    def _snake_case			(   self							):
       lowercase__:   Optional[int]					=      (
           '''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
           ''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
       )
       lowercase__:   Optional[int]					=      [
           108,
           265,
           24,
           111,
           4,
           258,
           156,
           35,
           28,
           275,
           3,
           259,
           297,
           260,
           84,
           4,
           35,
           110,
           44,
           8,
           259,
           91,
           268,
           21,
           11,
           209,
           274,
           109,
           266,
           277,
           117,
           86,
           93,
           315,
           258,
           278,
           258,
           277,
           258,
           0,
           258,
           288,
           258,
           319,
           258,
           0,
           258,
           0,
           258,
           0,
           258,
           0,
           258,
           287,
           258,
           315,
           258,
           289,
           258,
           278,
           99,
           269,
           266,
           262,
           8,
           259,
           241,
           4,
           217,
           230,
           268,
           266,
           55,
           168,
           106,
           75,
           193,
           266,
           223,
           27,
           49,
           26,
           282,
           25,
           264,
           299,
           19,
           26,
           0,
           258,
           277,
           117,
           86,
           93,
           176,
           183,
           270,
           11,
           262,
           42,
           61,
           265,
       ]

       self.assertListEqual(_UpperCAmelCase    ,			self.big_tokenizer.encode(_UpperCAmelCase							)							)






    @require_torch
    @slow
    def _snake_case			(   self							):
       import torch

       from transformers import ReformerConfig, ReformerModel

       # Build sequence
       lowercase__:   Union[str, Any]					=      list(self.big_tokenizer.get_vocab().keys()							)[:10]
       lowercase__:   List[str]					=      ''' '''.join(_UpperCAmelCase							)
       lowercase__:   str					=      self.big_tokenizer.encode_plus(_UpperCAmelCase    ,			return_tensors='''pt'''							)
       lowercase__:   List[str]					=      self.big_tokenizer.batch_encode_plus([sequence, sequence]    ,			return_tensors='''pt'''							)

       lowercase__:   Any					=      ReformerConfig()
       # The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
       lowercase__:   Any					=      encoded_sequence['''input_ids'''].shape
       lowercase__:   Optional[int]					=      ReformerModel(_UpperCAmelCase							)

       # Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
       assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

       with torch.no_grad():
          model(**_UpperCAmelCase							)
          model(**_UpperCAmelCase							)






    @slow
    def _snake_case			(   self							):
       # fmt: off
       lowercase__:   List[str]					=      {'''input_ids''': [[108, 265, 24, 111, 4, 258, 156, 7, 51, 279, 58, 7, 76, 25, 69, 278], [140, 243, 264, 134, 17, 267, 77, 263, 22, 262, 297, 258, 304, 177, 279, 266, 14, 89, 13, 35, 261, 299, 272, 137, 275, 278]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
       # fmt: on

       # This tokenizer does not know some characters like ")".
       # That is the reason why we use very simple texts here.
       # Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
       lowercase__:   Dict					=      [
           '''This is a very simple sentence.''',
           '''The quick brown fox jumps over the lazy dog.''',
       ]

       self.tokenizer_integration_test_util(
           expected_encoding=_UpperCAmelCase    ,			model_name='''google/reformer-crime-and-punishment'''    ,			revision='''0e6c3decb8211d49bf881013425dc8b0448b3f5a'''    ,			padding=_UpperCAmelCase    ,			sequences=_UpperCAmelCase    ,			)

"""simple docstring"""






def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   if n == 1 or not isinstance(__UpperCAmelCase       ,    __UpperCAmelCase ):
      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 SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   lowercase__:   Union[str, Any]					=      0
   lowercase__:   List[Any]					=      2

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

   return index



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase = 1_0_0_0 )  ->  int:
   return fibonacci_digits_index(__UpperCAmelCase )


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