

'''simple docstring'''
from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


_snake_case     =  logging.get_logger(__name__)


class    a__  (							_UpperCAmelCase  ):
   _SCREAMING_SNAKE_CASE    :     str	       =							["pixel_values"]


   def __init__( self			,				_UpperCamelCase = True			,				_UpperCamelCase = None			,				_UpperCamelCase = PILImageResampling.BILINEAR			,				_UpperCamelCase = True			,				_UpperCamelCase = None			,				_UpperCamelCase = True			,				_UpperCamelCase = 1 / 255			,				_UpperCamelCase = True			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				**_UpperCamelCase			,				):





      """simple docstring"""





      super().__init__(**_UpperCAmelCase  )
      _lowercase			:      Optional[int]			     =   size if size is not None else {'''shortest_edge''': 256}
      _lowercase			:      Any			     =   get_size_dict(_UpperCAmelCase			,				default_to_square=_UpperCAmelCase  )
      _lowercase			:      Optional[Any]			     =   crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
      _lowercase			:      str			     =   get_size_dict(_UpperCAmelCase  )
      _lowercase			:      int			     =   do_resize
      _lowercase			:      str			     =   size
      _lowercase			:      Dict			     =   resample
      _lowercase			:      Dict			     =   do_center_crop
      _lowercase			:      List[Any]			     =   crop_size
      _lowercase			:      str			     =   do_rescale
      _lowercase			:      str			     =   rescale_factor
      _lowercase			:      List[str]			     =   do_normalize
      _lowercase			:      List[Any]			     =   image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
      _lowercase			:      List[Any]			     =   image_std if image_std is not None else IMAGENET_STANDARD_STD


   def 						_lowerCamelCase   ( self			,				_UpperCamelCase			,				_UpperCamelCase			,				_UpperCamelCase = PILImageResampling.BICUBIC			,				_UpperCamelCase = None			,				**_UpperCamelCase			,				):





      """simple docstring"""





      _lowercase			:      str			     =   get_size_dict(_UpperCAmelCase			,				default_to_square=_UpperCAmelCase  )
      if "shortest_edge" not in size:
         raise ValueError(f'''The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'''  )
      _lowercase			:      List[str]			     =   get_resize_output_image_size(_UpperCAmelCase			,				size=size["shortest_edge"]			,				default_to_square=_UpperCAmelCase  )
      return resize(_UpperCAmelCase			,				size=_UpperCAmelCase			,				resample=_UpperCAmelCase			,				data_format=_UpperCAmelCase			,				**_UpperCAmelCase  )


   def 						_lowerCamelCase   ( self			,				_UpperCamelCase			,				_UpperCamelCase			,				_UpperCamelCase = None			,				**_UpperCamelCase			,				):





      """simple docstring"""





      _lowercase			:      List[Any]			     =   get_size_dict(_UpperCAmelCase  )
      return center_crop(_UpperCAmelCase			,				size=(size["height"], size["width"])			,				data_format=_UpperCAmelCase			,				**_UpperCAmelCase  )


   def 						_lowerCamelCase   ( self			,				_UpperCamelCase			,				_UpperCamelCase			,				_UpperCamelCase = None			,				**_UpperCamelCase  ):





      """simple docstring"""





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


   def 						_lowerCamelCase   ( self			,				_UpperCamelCase			,				_UpperCamelCase			,				_UpperCamelCase			,				_UpperCamelCase = None			,				**_UpperCamelCase			,				):





      """simple docstring"""





      return normalize(_UpperCAmelCase			,				mean=_UpperCAmelCase			,				std=_UpperCAmelCase			,				data_format=_UpperCAmelCase			,				**_UpperCAmelCase  )






   def 						_lowerCamelCase   ( self			,				_UpperCamelCase			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = None			,				_UpperCamelCase = ChannelDimension.FIRST			,				**_UpperCamelCase			,				):





      """simple docstring"""





      _lowercase			:      Any			     =   do_resize if do_resize is not None else self.do_resize
      _lowercase			:      Optional[Any]			     =   size if size is not None else self.size
      _lowercase			:      Tuple			     =   get_size_dict(_UpperCAmelCase			,				default_to_square=_UpperCAmelCase  )
      _lowercase			:      Any			     =   resample if resample is not None else self.resample
      _lowercase			:      int			     =   do_center_crop if do_center_crop is not None else self.do_center_crop
      _lowercase			:      int			     =   crop_size if crop_size is not None else self.crop_size
      _lowercase			:      Optional[int]			     =   get_size_dict(_UpperCAmelCase  )
      _lowercase			:      str			     =   do_rescale if do_rescale is not None else self.do_rescale
      _lowercase			:      Union[str, Any]			     =   rescale_factor if rescale_factor is not None else self.rescale_factor
      _lowercase			:      List[str]			     =   do_normalize if do_normalize is not None else self.do_normalize
      _lowercase			:      Dict			     =   image_mean if image_mean is not None else self.image_mean
      _lowercase			:      List[Any]			     =   image_std if image_std is not None else self.image_std

      _lowercase			:      Dict			     =   make_list_of_images(_UpperCAmelCase  )

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

      if do_resize and size is None:
         raise ValueError("Size must be specified if do_resize is True."  )

      if do_center_crop and crop_size is None:
         raise ValueError("Crop size must be specified if do_center_crop is True."  )

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

      if do_normalize and (image_mean is None or image_std is None):
         raise ValueError("Image mean and std must be specified if do_normalize is True."  )

      # All transformations expect numpy arrays.
      _lowercase			:      List[Any]			     =   [to_numpy_array(_UpperCAmelCase  ) for image in images]

      if do_resize:
         _lowercase			:      int			     =   [self.resize(image=_UpperCAmelCase			,				size=_UpperCAmelCase			,				resample=_UpperCAmelCase  ) for image in images]

      if do_center_crop:
         _lowercase			:      Optional[Any]			     =   [self.center_crop(image=_UpperCAmelCase			,				size=_UpperCAmelCase  ) for image in images]

      if do_rescale:
         _lowercase			:      Dict			     =   [self.rescale(image=_UpperCAmelCase			,				scale=_UpperCAmelCase  ) for image in images]

      if do_normalize:
         _lowercase			:      List[str]			     =   [self.normalize(image=_UpperCAmelCase			,				mean=_UpperCAmelCase			,				std=_UpperCAmelCase  ) for image in images]

      _lowercase			:      int			     =   [to_channel_dimension_format(_UpperCAmelCase			,				_UpperCAmelCase  ) for image in images]

      _lowercase			:      List[Any]			     =   {'''pixel_values''': images}
      return BatchFeature(data=_UpperCAmelCase			,				tensor_type=_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())))
