




'''simple docstring'''


from typing import Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import get_image_size, pad, rescale, to_channel_dimension_format
from ...image_utils import ChannelDimension, ImageInput, make_list_of_images, to_numpy_array, valid_images
from ...utils import TensorType, logging


_snake_case   :   List[Any]     							=	logging.get_logger(__name__)

class     A					(	_a					):
							lowercase_           =       ['pixel_values']







							def __init__(						self :						Optional[int]							,    lowerCAmelCase_ :						bool = True							,    lowerCAmelCase_ :						Union[int, float] = 1 / 2_55							,    lowerCAmelCase_ :						bool = True							,    lowerCAmelCase_ :						int = 8							,    **lowerCAmelCase_ :						str							,    )    ->							None:


														"""simple docstring"""


														super().__init__(**lowerCAmelCase_      )

														_a			  =       do_rescale
														_a			  =       rescale_factor
														_a			  =       do_pad
														_a			  =       pad_size







							def      __lowerCAmelCase    (						self :						Dict							,    lowerCAmelCase_ :						np.ndarray							,    lowerCAmelCase_ :						float							,    lowerCAmelCase_ :						Optional[Union[str, ChannelDimension]] = None							,    **lowerCAmelCase_ :						Optional[int]      )    ->							np.ndarray:


														"""simple docstring"""


														return rescale(lowerCAmelCase_							,    scale=lowerCAmelCase_							,    data_format=lowerCAmelCase_							,    **lowerCAmelCase_      )







							def      __lowerCAmelCase    (						self :						str							,    lowerCAmelCase_ :						np.ndarray							,    lowerCAmelCase_ :						int							,    lowerCAmelCase_ :						Optional[Union[str, ChannelDimension]] = None      )    ->							Optional[Any]:


														"""simple docstring"""


														_a  ,							_a			  =       get_image_size(lowerCAmelCase_      )
														_a			  =       (old_height // size + 1) * size - old_height
														_a			  =       (old_width // size + 1) * size - old_width

														return pad(lowerCAmelCase_							,    ((0, pad_height), (0, pad_width))							,    mode='''symmetric'''							,    data_format=lowerCAmelCase_      )







							def      __lowerCAmelCase    (						self :						List[Any]							,    lowerCAmelCase_ :						ImageInput							,    lowerCAmelCase_ :						Optional[bool] = None							,    lowerCAmelCase_ :						Optional[float] = None							,    lowerCAmelCase_ :						Optional[bool] = None							,    lowerCAmelCase_ :						Optional[int] = None							,    lowerCAmelCase_ :						Optional[Union[str, TensorType]] = None							,    lowerCAmelCase_ :						Union[str, ChannelDimension] = ChannelDimension.FIRST							,    **lowerCAmelCase_ :						Any							,    )    ->							str:


														"""simple docstring"""


														_a			  =       do_rescale if do_rescale is not None else self.do_rescale
														_a			  =       rescale_factor if rescale_factor is not None else self.rescale_factor
														_a			  =       do_pad if do_pad is not None else self.do_pad
														_a			  =       pad_size if pad_size is not None else self.pad_size

														_a			  =       make_list_of_images(lowerCAmelCase_      )

														if not valid_images(lowerCAmelCase_      ):
																					raise ValueError(
																					    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
																					    '''torch.Tensor, tf.Tensor or jax.ndarray.'''      )

														if do_rescale and rescale_factor is None:
																					raise ValueError('''Rescale factor must be specified if do_rescale is True.'''      )

														# All transformations expect numpy arrays.
														_a			  =       [to_numpy_array(lowerCAmelCase_      ) for image in images]

														if do_rescale:
																					_a			  =       [self.rescale(image=lowerCAmelCase_							,    scale=lowerCAmelCase_      ) for image in images]

														if do_pad:
																					_a			  =       [self.pad(lowerCAmelCase_							,    size=lowerCAmelCase_      ) for image in images]

														_a			  =       [to_channel_dimension_format(lowerCAmelCase_							,    lowerCAmelCase_      ) for image in images]

														_a			  =       {'''pixel_values''': images}
														return BatchFeature(data=lowerCAmelCase_							,    tensor_type=lowerCAmelCase_      )







'''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())))

