




import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


UpperCAmelCase_				:			Tuple   =	get_tests_dir('fixtures')
UpperCAmelCase_				:			Union[str, Any]   =	get_tests_dir('fixtures/dummy_feature_extractor_config.json')
UpperCAmelCase_				:			Tuple   =	get_tests_dir('fixtures/dummy-config.json')
class 			SCREAMING_SNAKE_CASE__  (    unittest.TestCase      ):
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[Any]					)		->      int:
             a_ :		Any							=  0
      def 	SCREAMING_SNAKE_CASE							(	self    :	int					)		->      Dict:
             a_ :		int							=  AutoFeatureExtractor.from_pretrained('facebook/wav2vec2-base-960h'					)
             self.assertIsInstance(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	str					)		->      Optional[Any]:
             a_ :		Tuple							=  AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					)
             self.assertIsInstance(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					)		->      str:
             with tempfile.TemporaryDirectory() as tmpdirname:
                    a_ :		List[str]							=  WavaVecaConfig()

                    # remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
                    a_ :		Dict							=  AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					).to_dict()

                    config_dict.pop('feature_extractor_type'					)
                    a_ :		Any							=  WavaVecaFeatureExtractor(**SCREAMING_SNAKE_CASE__					)

                    # save in new folder
                    model_config.save_pretrained(SCREAMING_SNAKE_CASE__					)
                    config.save_pretrained(SCREAMING_SNAKE_CASE__					)

                    a_ :		List[Any]							=  AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					)

                    # make sure private variable is not incorrectly saved
                    a_ :		Tuple							=  json.loads(config.to_json_string()					)
                    self.assertTrue('_processor_class' not in dict_as_saved					)

             self.assertIsInstance(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[Any]					)		->      Union[str, Any]:
             a_ :		Optional[Any]							=  AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					)
             self.assertIsInstance(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Any					)		->      Optional[int]:
             with self.assertRaisesRegex(
                 SCREAMING_SNAKE_CASE__					,							'bert-base is not a local folder and is not a valid model identifier'					):
                    a_ :		List[Any]							=  AutoFeatureExtractor.from_pretrained('bert-base'					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Union[str, Any]					)		->      Optional[Any]:
             with self.assertRaisesRegex(
                 SCREAMING_SNAKE_CASE__					,							r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'					):
                    a_ :		List[str]							=  AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					,							revision='aaaaaa'					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[int]					)		->      Dict:
             with self.assertRaisesRegex(
                 SCREAMING_SNAKE_CASE__					,							'hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'					,							):
                    a_ :		List[Any]							=  AutoFeatureExtractor.from_pretrained('hf-internal-testing/config-no-model'					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					)		->      int:
             # If remote code is not set, we will time out when asking whether to load the model.
             with self.assertRaises(SCREAMING_SNAKE_CASE__					):
                    a_ :		List[Any]							=  AutoFeatureExtractor.from_pretrained(
                        'hf-internal-testing/test_dynamic_feature_extractor'					)
             # If remote code is disabled, we can't load this config.
             with self.assertRaises(SCREAMING_SNAKE_CASE__					):
                    a_ :		Optional[Any]							=  AutoFeatureExtractor.from_pretrained(
                        'hf-internal-testing/test_dynamic_feature_extractor'					,							trust_remote_code=SCREAMING_SNAKE_CASE__					)

             a_ :		List[str]							=  AutoFeatureExtractor.from_pretrained(
                 'hf-internal-testing/test_dynamic_feature_extractor'					,							trust_remote_code=SCREAMING_SNAKE_CASE__					)
             self.assertEqual(feature_extractor.__class__.__name__					,							'NewFeatureExtractor'					)

             # Test feature extractor can be reloaded.
             with tempfile.TemporaryDirectory() as tmp_dir:
                    feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE__					)
                    a_ :		List[Any]							=  AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					,							trust_remote_code=SCREAMING_SNAKE_CASE__					)
             self.assertEqual(reloaded_feature_extractor.__class__.__name__					,							'NewFeatureExtractor'					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[Any]					)		->      Dict:
             try:
                    AutoConfig.register('custom'					,							SCREAMING_SNAKE_CASE__					)
                    AutoFeatureExtractor.register(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
                    # Trying to register something existing in the Transformers library will raise an error
                    with self.assertRaises(SCREAMING_SNAKE_CASE__					):
                           AutoFeatureExtractor.register(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)

                    # Now that the config is registered, it can be used as any other config with the auto-API
                    a_ :		int							=  CustomFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					)
                    with tempfile.TemporaryDirectory() as tmp_dir:
                           feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE__					)
                           a_ :		Any							=  AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__					)
                           self.assertIsInstance(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)

             finally:
                    if "custom" in CONFIG_MAPPING._extra_content:
                           del CONFIG_MAPPING._extra_content["custom"]
                    if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                           del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]

      def 	SCREAMING_SNAKE_CASE							(	self    :	Any					)		->      List[str]:
             class 			SCREAMING_SNAKE_CASE__  (    lowercase__      ):
                   snake_case__    :					List[str]					       =						True

             try:
                    AutoConfig.register('custom'					,							SCREAMING_SNAKE_CASE__					)
                    AutoFeatureExtractor.register(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
                    # If remote code is not set, the default is to use local
                    a_ :		Union[str, Any]							=  AutoFeatureExtractor.from_pretrained(
                        'hf-internal-testing/test_dynamic_feature_extractor'					)
                    self.assertEqual(feature_extractor.__class__.__name__					,							'NewFeatureExtractor'					)
                    self.assertTrue(feature_extractor.is_local					)

                    # If remote code is disabled, we load the local one.
                    a_ :		Dict							=  AutoFeatureExtractor.from_pretrained(
                        'hf-internal-testing/test_dynamic_feature_extractor'					,							trust_remote_code=SCREAMING_SNAKE_CASE__					)
                    self.assertEqual(feature_extractor.__class__.__name__					,							'NewFeatureExtractor'					)
                    self.assertTrue(feature_extractor.is_local					)

                    # If remote is enabled, we load from the Hub
                    a_ :		Optional[int]							=  AutoFeatureExtractor.from_pretrained(
                        'hf-internal-testing/test_dynamic_feature_extractor'					,							trust_remote_code=SCREAMING_SNAKE_CASE__					)
                    self.assertEqual(feature_extractor.__class__.__name__					,							'NewFeatureExtractor'					)
                    self.assertTrue(not hasattr(SCREAMING_SNAKE_CASE__					,							'is_local'					)					)

             finally:
                    if "custom" in CONFIG_MAPPING._extra_content:
                           del CONFIG_MAPPING._extra_content["custom"]
                    if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                           del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]






def 	SCREAMING_SNAKE_CASE_						(      __A			:      int    )     ->		int:

       """simple docstring"""

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

              return sequence[n]







def 	SCREAMING_SNAKE_CASE_						(      __A			:      int    )     ->		int:

       """simple docstring"""

       a_ :		Any							=  0
       a_ :		Optional[Any]							=  2

       while digits < n:
              index += 1
              a_ :		List[Any]							=  len(str(fibonacci(__A    )    )    )

       return index







def 	SCREAMING_SNAKE_CASE_						(      __A			:      int = 10_00    )     ->		int:

       """simple docstring"""

       return fibonacci_digits_index(__A    )


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


