






'''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,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
      import PIL


UpperCamelCase							=logging.get_logger(__name__)



def 							snake_case					(     a_							: Optional[int]	)       ->				List[List[ImageInput]]:





      """simple docstring"""

      if isinstance(a_    ,   (list, tuple)	) and isinstance(videos[0]    ,   (list, tuple)	) and is_valid_image(videos[0][0]	):
            return videos

      elif isinstance(a_    ,   (list, tuple)	) and is_valid_image(videos[0]	):
            return [videos]

      elif is_valid_image(a_	):
            return [[videos]]

      raise ValueError(f"Could not make batched video from {videos}"	)




class     A    (      SCREAMING_SNAKE_CASE__						):






 """simple docstring"""





 __a			:						Optional[int]      =						['''pixel_values''']
 def __init__(							self			,     __lowerCAmelCase = True			,     __lowerCAmelCase = None			,     __lowerCAmelCase = PILImageResampling.BILINEAR			,     __lowerCAmelCase = True			,     __lowerCAmelCase = None			,     __lowerCAmelCase = True			,     __lowerCAmelCase = 1 / 2_55			,     __lowerCAmelCase = True			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     **__lowerCAmelCase			,     ):
       super().__init__(**__lowerCAmelCase )
       UpperCamelCase_				:   List[Any]					    =							size if size is not None else {"""shortest_edge""": 2_24}
       UpperCamelCase_				:   Any					    =							get_size_dict(__lowerCAmelCase			,     default_to_square=__lowerCAmelCase )
       UpperCamelCase_				:   Dict					    =							crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24}
       UpperCamelCase_				:   Optional[int]					    =							get_size_dict(__lowerCAmelCase			,     param_name="""crop_size""" )

       UpperCamelCase_				:   int					    =							do_resize
       UpperCamelCase_				:   Dict					    =							size
       UpperCamelCase_				:   Dict					    =							do_center_crop
       UpperCamelCase_				:   Optional[Any]					    =							crop_size
       UpperCamelCase_				:   Union[str, Any]					    =							resample
       UpperCamelCase_				:   Dict					    =							do_rescale
       UpperCamelCase_				:   str					    =							rescale_factor
       UpperCamelCase_				:   Dict					    =							do_normalize
       UpperCamelCase_				:   Optional[Any]					    =							image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
       UpperCamelCase_				:   Optional[Any]					    =							image_std if image_std is not None else IMAGENET_STANDARD_STD
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase = PILImageResampling.BILINEAR			,     __lowerCAmelCase = None			,     **__lowerCAmelCase			,     ):
       UpperCamelCase_				:   Union[str, Any]					    =							get_size_dict(__lowerCAmelCase			,     default_to_square=__lowerCAmelCase )
       if "shortest_edge" in size:
             UpperCamelCase_				:   int					    =							get_resize_output_image_size(__lowerCAmelCase			,     size["""shortest_edge"""]			,     default_to_square=__lowerCAmelCase )
       elif "height" in size and "width" in size:
             UpperCamelCase_				:   int					    =							(size["""height"""], size["""width"""])
       else:
             raise ValueError(F"Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}" )
       return resize(__lowerCAmelCase			,     size=__lowerCAmelCase			,     resample=__lowerCAmelCase			,     data_format=__lowerCAmelCase			,     **__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase = None			,     **__lowerCAmelCase			,     ):
       UpperCamelCase_				:   Any					    =							get_size_dict(__lowerCAmelCase )
       if "height" not in size or "width" not in size:
             raise ValueError(F"Size must have 'height' and 'width' as keys. Got {size.keys()}" )
       return center_crop(__lowerCAmelCase			,     size=(size["""height"""], size["""width"""])			,     data_format=__lowerCAmelCase			,     **__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase = None			,     **__lowerCAmelCase			,     ):
       return rescale(__lowerCAmelCase			,     scale=__lowerCAmelCase			,     data_format=__lowerCAmelCase			,     **__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase = None			,     **__lowerCAmelCase			,     ):
       return normalize(__lowerCAmelCase			,     mean=__lowerCAmelCase			,     std=__lowerCAmelCase			,     data_format=__lowerCAmelCase			,     **__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = ChannelDimension.FIRST			,     ):
       if do_resize and size is None or resample is None:
             raise ValueError("""Size and resample 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.
       UpperCamelCase_				:   Optional[int]					    =							to_numpy_array(__lowerCAmelCase )

       if do_resize:
             UpperCamelCase_				:   Optional[int]					    =							self.resize(image=__lowerCAmelCase			,     size=__lowerCAmelCase			,     resample=__lowerCAmelCase )

       if do_center_crop:
             UpperCamelCase_				:   List[Any]					    =							self.center_crop(__lowerCAmelCase			,     size=__lowerCAmelCase )

       if do_rescale:
             UpperCamelCase_				:   List[str]					    =							self.rescale(image=__lowerCAmelCase			,     scale=__lowerCAmelCase )

       if do_normalize:
             UpperCamelCase_				:   Tuple					    =							self.normalize(image=__lowerCAmelCase			,     mean=__lowerCAmelCase			,     std=__lowerCAmelCase )

       UpperCamelCase_				:   str					    =							to_channel_dimension_format(__lowerCAmelCase			,     __lowerCAmelCase )
       return image





 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     __lowerCAmelCase = ChannelDimension.FIRST			,     **__lowerCAmelCase			,     ):
       UpperCamelCase_				:   int					    =							do_resize if do_resize is not None else self.do_resize
       UpperCamelCase_				:   int					    =							resample if resample is not None else self.resample
       UpperCamelCase_				:   Optional[Any]					    =							do_center_crop if do_center_crop is not None else self.do_center_crop
       UpperCamelCase_				:   str					    =							do_rescale if do_rescale is not None else self.do_rescale
       UpperCamelCase_				:   int					    =							rescale_factor if rescale_factor is not None else self.rescale_factor
       UpperCamelCase_				:   int					    =							do_normalize if do_normalize is not None else self.do_normalize
       UpperCamelCase_				:   Tuple					    =							image_mean if image_mean is not None else self.image_mean
       UpperCamelCase_				:   Tuple					    =							image_std if image_std is not None else self.image_std

       UpperCamelCase_				:   int					    =							size if size is not None else self.size
       UpperCamelCase_				:   int					    =							get_size_dict(__lowerCAmelCase			,     default_to_square=__lowerCAmelCase )
       UpperCamelCase_				:   str					    =							crop_size if crop_size is not None else self.crop_size
       UpperCamelCase_				:   Any					    =							get_size_dict(__lowerCAmelCase			,     param_name="""crop_size""" )

       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.""" )

       UpperCamelCase_				:   str					    =							make_batched(__lowerCAmelCase )

       UpperCamelCase_				:   Dict					    =							[
           [
               self._preprocess_image(
                   image=__lowerCAmelCase			,     do_resize=__lowerCAmelCase			,     size=__lowerCAmelCase			,     resample=__lowerCAmelCase			,     do_center_crop=__lowerCAmelCase			,     crop_size=__lowerCAmelCase			,     do_rescale=__lowerCAmelCase			,     rescale_factor=__lowerCAmelCase			,     do_normalize=__lowerCAmelCase			,     image_mean=__lowerCAmelCase			,     image_std=__lowerCAmelCase			,     data_format=__lowerCAmelCase			,     )
               for img in video
           ]
           for video in videos
       ]

       UpperCamelCase_				:   Optional[int]					    =							{"""pixel_values""": videos}
       return BatchFeature(data=__lowerCAmelCase			,     tensor_type=__lowerCAmelCase )














'''simple docstring'''

def 							snake_case					(     )       ->				int:





      """simple docstring"""

      return 1



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

      return 0 if x < 0 else two_pence(x - 2	) + one_pence()



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

      return 0 if x < 0 else five_pence(x - 5	) + two_pence(a_	)



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

      return 0 if x < 0 else ten_pence(x - 10	) + five_pence(a_	)



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

      return 0 if x < 0 else twenty_pence(x - 20	) + ten_pence(a_	)



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

      return 0 if x < 0 else fifty_pence(x - 50	) + twenty_pence(a_	)



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

      return 0 if x < 0 else one_pound(x - 100	) + fifty_pence(a_	)



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

      return 0 if x < 0 else two_pound(x - 200	) + one_pound(a_	)



def 							snake_case					(     a_							: int = 200	)       ->				int:





      """simple docstring"""

      return two_pound(a_	)


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






