




'''simple docstring'''


import unittest

import numpy as np

from transformers.file_utils import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
				import torch

if is_vision_available():
				from PIL import Image

				from transformers import DPTImageProcessor

class     A					(	unittest.TestCase					):







							def __init__(						self :						int							,    lowerCAmelCase_ :						Union[str, Any]							,    lowerCAmelCase_ :						Any=7							,    lowerCAmelCase_ :						Dict=3							,    lowerCAmelCase_ :						List[str]=18							,    lowerCAmelCase_ :						Optional[int]=30							,    lowerCAmelCase_ :						int=4_00							,    lowerCAmelCase_ :						Tuple=True							,    lowerCAmelCase_ :						List[str]=None							,    lowerCAmelCase_ :						List[str]=True							,    lowerCAmelCase_ :						Union[str, Any]=[0.5, 0.5, 0.5]							,    lowerCAmelCase_ :						Any=[0.5, 0.5, 0.5]							,    )    ->							Tuple:


														"""simple docstring"""


														_a			  =       size if size is not None else {"""height""": 18, """width""": 18}
														_a			  =       parent
														_a			  =       batch_size
														_a			  =       num_channels
														_a			  =       image_size
														_a			  =       min_resolution
														_a			  =       max_resolution
														_a			  =       do_resize
														_a			  =       size
														_a			  =       do_normalize
														_a			  =       image_mean
														_a			  =       image_std







							def      __lowerCAmelCase    (						self :						str      )    ->							Any:


														"""simple docstring"""


														return {
														    "image_mean": self.image_mean,
														    "image_std": self.image_std,
														    "do_normalize": self.do_normalize,
														    "do_resize": self.do_resize,
														    "size": self.size,
														}



@require_torch
@require_vision
class     A					(	UpperCamelCase__  ,unittest.TestCase					):
							lowercase_           =       DPTImageProcessor if is_vision_available() else None







							def      __lowerCAmelCase    (						self :						List[Any]      )    ->							Optional[int]:


														"""simple docstring"""


														_a			  =       DPTImageProcessingTester(self      )







							@property
							def      __lowerCAmelCase    (						self :						Dict      )    ->							Tuple:


														"""simple docstring"""


														return self.image_processor_tester.prepare_image_processor_dict()







							def      __lowerCAmelCase    (						self :						str      )    ->							Any:


														"""simple docstring"""


														_a			  =       self.image_processing_class(**self.image_processor_dict      )
														self.assertTrue(hasattr(_a							,    '''image_mean'''      )      )
														self.assertTrue(hasattr(_a							,    '''image_std'''      )      )
														self.assertTrue(hasattr(_a							,    '''do_normalize'''      )      )
														self.assertTrue(hasattr(_a							,    '''do_resize'''      )      )
														self.assertTrue(hasattr(_a							,    '''size'''      )      )







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


														"""simple docstring"""


														_a			  =       self.image_processing_class.from_dict(self.image_processor_dict      )
														self.assertEqual(image_processor.size							,    {'''height''': 18, '''width''': 18}      )

														_a			  =       self.image_processing_class.from_dict(self.image_processor_dict							,    size=42      )
														self.assertEqual(image_processor.size							,    {'''height''': 42, '''width''': 42}      )







							def      __lowerCAmelCase    (						self :						int      )    ->							List[Any]:


														"""simple docstring"""


														_a			  =       self.image_processing_class(**self.image_processor_dict      )
														# create random PIL images
														_a			  =       prepare_image_inputs(self.image_processor_tester							,    equal_resolution=_a      )
														for image in image_inputs:
																					self.assertIsInstance(_a							,    Image.Image      )

														# Test not batched input
														_a			  =       image_processing(image_inputs[0]							,    return_tensors='''pt'''      ).pixel_values
														self.assertEqual(
														    encoded_images.shape							,    (
														        1,
														        self.image_processor_tester.num_channels,
														        self.image_processor_tester.size['''height'''],
														        self.image_processor_tester.size['''width'''],
														    )							,    )

														# Test batched
														_a			  =       image_processing(_a							,    return_tensors='''pt'''      ).pixel_values
														self.assertEqual(
														    encoded_images.shape							,    (
														        self.image_processor_tester.batch_size,
														        self.image_processor_tester.num_channels,
														        self.image_processor_tester.size['''height'''],
														        self.image_processor_tester.size['''width'''],
														    )							,    )







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


														"""simple docstring"""


														_a			  =       self.image_processing_class(**self.image_processor_dict      )
														# create random numpy tensors
														_a			  =       prepare_image_inputs(self.image_processor_tester							,    equal_resolution=_a							,    numpify=_a      )
														for image in image_inputs:
																					self.assertIsInstance(_a							,    np.ndarray      )

														# Test not batched input
														_a			  =       image_processing(image_inputs[0]							,    return_tensors='''pt'''      ).pixel_values
														self.assertEqual(
														    encoded_images.shape							,    (
														        1,
														        self.image_processor_tester.num_channels,
														        self.image_processor_tester.size['''height'''],
														        self.image_processor_tester.size['''width'''],
														    )							,    )

														# Test batched
														_a			  =       image_processing(_a							,    return_tensors='''pt'''      ).pixel_values
														self.assertEqual(
														    encoded_images.shape							,    (
														        self.image_processor_tester.batch_size,
														        self.image_processor_tester.num_channels,
														        self.image_processor_tester.size['''height'''],
														        self.image_processor_tester.size['''width'''],
														    )							,    )







							def      __lowerCAmelCase    (						self :						Optional[int]      )    ->							List[str]:


														"""simple docstring"""


														_a			  =       self.image_processing_class(**self.image_processor_dict      )
														# create random PyTorch tensors
														_a			  =       prepare_image_inputs(self.image_processor_tester							,    equal_resolution=_a							,    torchify=_a      )
														for image in image_inputs:
																					self.assertIsInstance(_a							,    torch.Tensor      )

														# Test not batched input
														_a			  =       image_processing(image_inputs[0]							,    return_tensors='''pt'''      ).pixel_values
														self.assertEqual(
														    encoded_images.shape							,    (
														        1,
														        self.image_processor_tester.num_channels,
														        self.image_processor_tester.size['''height'''],
														        self.image_processor_tester.size['''width'''],
														    )							,    )

														# Test batched
														_a			  =       image_processing(_a							,    return_tensors='''pt'''      ).pixel_values
														self.assertEqual(
														    encoded_images.shape							,    (
														        self.image_processor_tester.batch_size,
														        self.image_processor_tester.num_channels,
														        self.image_processor_tester.size['''height'''],
														        self.image_processor_tester.size['''width'''],
														    )							,    )







'''simple docstring'''


def 	snake_case_					(UpperCamelCase :						int   ):





							'''simple docstring'''


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

														return sequence[n]
def 	snake_case_					(UpperCamelCase :						int   ):





							'''simple docstring'''


							_a			  =       0
							_a			  =       2

							while digits < n:
														index += 1
														_a			  =       len(str(fibonacci(UpperCamelCase   )   )   )

							return index
def 	snake_case_					(UpperCamelCase :						int = 1000   ):





							'''simple docstring'''


							return fibonacci_digits_index(UpperCamelCase   )


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

