"""simple docstring"""






import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoImageProcessor, ViTImageProcessor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


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

from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


UpperCamelCase         =  get_tests_dir('fixtures')
class 	UpperCAmelCase__					(     unittest.TestCase      ):


	"""simple docstring"""







	def    A     (      self			)     ->						Dict:
							# A mock response for an HTTP head request to emulate server down
							a_				:      int  		=       mock.Mock()
							a_				:      str  		=       5_0_0
							a_				:      Optional[Any]  		=       {}
							a_				:      Dict  		=       HTTPError
							a_				:      Dict  		=       {}

							# Download this model to make sure it's in the cache.
							a_				:      List[str]  		=       ViTImageProcessor.from_pretrained("hf-internal-testing/tiny-random-vit"			)
							# Under the mock environment we get a 500 error when trying to reach the model.
							with mock.patch("requests.Session.request"							,  return_value=__lowerCAmelCase			) as mock_head:
													a_				:      int  		=       ViTImageProcessor.from_pretrained("hf-internal-testing/tiny-random-vit"			)
													# This check we did call the fake head request
													mock_head.assert_called()







	def    A     (      self			)     ->						int:
							# This test is for deprecated behavior and can be removed in v5
							a_				:      Optional[Any]  		=       ViTImageProcessor.from_pretrained(
							    "https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"			)







	def    A     (      self			)     ->						Optional[int]:
							with self.assertRaises(__lowerCAmelCase			):
													# config is in subfolder, the following should not work without specifying the subfolder
													a_				:      Dict  		=       AutoImageProcessor.from_pretrained("hf-internal-testing/stable-diffusion-all-variants"			)

							a_				:      str  		=       AutoImageProcessor.from_pretrained(
							    "hf-internal-testing/stable-diffusion-all-variants"							,  subfolder="feature_extractor"			)

							self.assertIsNotNone(__lowerCAmelCase			)




@is_staging_test
class 	UpperCAmelCase__					(     unittest.TestCase      ):


	"""simple docstring"""







	@classmethod
	def    A     (      cls			)     ->						str:
							a_				:      str  		=       TOKEN
							HfFolder.save_token(__lowerCAmelCase			)







	@classmethod
	def    A     (      cls			)     ->						List[Any]:
							try:
													delete_repo(token=cls._token							,  repo_id="test-image-processor"			)
							except HTTPError:
													pass

							try:
													delete_repo(token=cls._token							,  repo_id="valid_org/test-image-processor-org"			)
							except HTTPError:
													pass

							try:
													delete_repo(token=cls._token							,  repo_id="test-dynamic-image-processor"			)
							except HTTPError:
													pass







	def    A     (      self			)     ->						Any:
							a_				:      Union[str, Any]  		=       ViTImageProcessor.from_pretrained(__lowerCAmelCase			)
							image_processor.push_to_hub("test-image-processor"							,  use_auth_token=self._token			)

							a_				:      List[Any]  		=       ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor'''			)
							for k, v in image_processor.__dict__.items():
													self.assertEqual(__lowerCAmelCase							,  getattr(__lowerCAmelCase							,  __lowerCAmelCase			)			)

							# Reset repo
							delete_repo(token=self._token							,  repo_id="test-image-processor"			)

							# Push to hub via save_pretrained
							with tempfile.TemporaryDirectory() as tmp_dir:
													image_processor.save_pretrained(
													    __lowerCAmelCase							,  repo_id="test-image-processor"							,  push_to_hub=__lowerCAmelCase							,  use_auth_token=self._token			)

							a_				:      Dict  		=       ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor'''			)
							for k, v in image_processor.__dict__.items():
													self.assertEqual(__lowerCAmelCase							,  getattr(__lowerCAmelCase							,  __lowerCAmelCase			)			)







	def    A     (      self			)     ->						Union[str, Any]:
							a_				:      List[str]  		=       ViTImageProcessor.from_pretrained(__lowerCAmelCase			)
							image_processor.push_to_hub("valid_org/test-image-processor"							,  use_auth_token=self._token			)

							a_				:      Tuple  		=       ViTImageProcessor.from_pretrained("valid_org/test-image-processor"			)
							for k, v in image_processor.__dict__.items():
													self.assertEqual(__lowerCAmelCase							,  getattr(__lowerCAmelCase							,  __lowerCAmelCase			)			)

							# Reset repo
							delete_repo(token=self._token							,  repo_id="valid_org/test-image-processor"			)

							# Push to hub via save_pretrained
							with tempfile.TemporaryDirectory() as tmp_dir:
													image_processor.save_pretrained(
													    __lowerCAmelCase							,  repo_id="valid_org/test-image-processor-org"							,  push_to_hub=__lowerCAmelCase							,  use_auth_token=self._token			)

							a_				:      Optional[Any]  		=       ViTImageProcessor.from_pretrained("valid_org/test-image-processor-org"			)
							for k, v in image_processor.__dict__.items():
													self.assertEqual(__lowerCAmelCase							,  getattr(__lowerCAmelCase							,  __lowerCAmelCase			)			)







	def    A     (      self			)     ->						Optional[Any]:
							CustomImageProcessor.register_for_auto_class()
							a_				:      Optional[Any]  		=       CustomImageProcessor.from_pretrained(__lowerCAmelCase			)

							image_processor.push_to_hub("test-dynamic-image-processor"							,  use_auth_token=self._token			)

							# This has added the proper auto_map field to the config
							self.assertDictEqual(
							    image_processor.auto_map							,  {"AutoImageProcessor": "custom_image_processing.CustomImageProcessor"}							,  )

							a_				:      Tuple  		=       AutoImageProcessor.from_pretrained(
							    f'''{USER}/test-dynamic-image-processor'''							,  trust_remote_code=__lowerCAmelCase			)
							# Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
							self.assertEqual(new_image_processor.__class__.__name__							,  "CustomImageProcessor"			)












'''simple docstring'''

def 				snake_case       (  a_				:			int						)							->					int:





      """simple docstring"""

      if n == 1 or not isinstance(a_     , a_						):
            return 0
      elif n == 2:
            return 1
      else:
            UpperCamelCase_					: Dict            =				[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						)							->					int:





      """simple docstring"""

      UpperCamelCase_					: Any            =				0
      UpperCamelCase_					: Union[str, Any]            =				2

      while digits < n:
            index += 1
            UpperCamelCase_					: Any            =				len(str(fibonacci(a_						)						)						)

      return index



def 				snake_case       (  a_				:			int = 1_000						)							->					int:





      """simple docstring"""

      return fibonacci_digits_index(a_						)


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






