



"""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, is_vision_available, logging


if is_vision_available():
  import PIL


lowerCamelCase  			=		logging.get_logger(__name__)
class  lowercase__  (       SCREAMING_SNAKE_CASE ):







       '''simple docstring'''


       UpperCamelCase		=	['''pixel_values''']



       def __init__(				self     :    int						,							_UpperCAmelCase     :    bool = True						,							_UpperCAmelCase     :    Dict[str, int] = None						,							_UpperCAmelCase     :    float = None						,							_UpperCAmelCase     :    PILImageResampling = PILImageResampling.BILINEAR						,							_UpperCAmelCase     :    bool = True						,							_UpperCAmelCase     :    Union[int, float] = 1 / 255						,							_UpperCAmelCase     :    bool = True						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							**_UpperCAmelCase     :    str						,							)					->		None:


             '''simple docstring'''




             super().__init__(**_UpperCAmelCase       )
             UpperCAmelCase_     					=				size if size is not None else {"shortest_edge": 384}
             UpperCAmelCase_     					=				get_size_dict(_UpperCAmelCase						,							default_to_square=_UpperCAmelCase       )

             UpperCAmelCase_     					=				do_resize
             UpperCAmelCase_     					=				size
             # Default value set here for backwards compatibility where the value in config is None
             UpperCAmelCase_     					=				crop_pct if crop_pct is not None else 224 / 256
             UpperCAmelCase_     					=				resample
             UpperCAmelCase_     					=				do_rescale
             UpperCAmelCase_     					=				rescale_factor
             UpperCAmelCase_     					=				do_normalize
             UpperCAmelCase_     					=				image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
             UpperCAmelCase_     					=				image_std if image_std is not None else IMAGENET_STANDARD_STD



       def 	lowercase__							(				self     :    Optional[int]						,							_UpperCAmelCase     :    np.ndarray						,							_UpperCAmelCase     :    Dict[str, int]						,							_UpperCAmelCase     :    float						,							_UpperCAmelCase     :    PILImageResampling = PILImageResampling.BICUBIC						,							_UpperCAmelCase     :    Optional[Union[str, ChannelDimension]] = None						,							**_UpperCAmelCase     :    Optional[int]						,							)					->		np.ndarray:


             '''simple docstring'''




             UpperCAmelCase_     					=				get_size_dict(_UpperCAmelCase						,							default_to_square=_UpperCAmelCase       )
             if "shortest_edge" not in size:
                   raise ValueError(F"""Size dictionary must contain 'shortest_edge' key. Got {size.keys()}"""       )
             UpperCAmelCase_     					=				size["shortest_edge"]

             if shortest_edge < 384:
                   # maintain same ratio, resizing shortest edge to shortest_edge/crop_pct
                   UpperCAmelCase_     					=				int(shortest_edge / crop_pct       )
                   UpperCAmelCase_     					=				get_resize_output_image_size(_UpperCAmelCase						,							size=_UpperCAmelCase						,							default_to_square=_UpperCAmelCase       )
                   UpperCAmelCase_     					=				resize(image=_UpperCAmelCase						,							size=_UpperCAmelCase						,							resample=_UpperCAmelCase						,							data_format=_UpperCAmelCase						,							**_UpperCAmelCase       )
                   # then crop to (shortest_edge, shortest_edge)
                   return center_crop(image=_UpperCAmelCase						,							size=(shortest_edge, shortest_edge)						,							data_format=_UpperCAmelCase						,							**_UpperCAmelCase       )
             else:
                   # warping (no cropping) when evaluated at 384 or larger
                   return resize(
                       _UpperCAmelCase						,							size=(shortest_edge, shortest_edge)						,							resample=_UpperCAmelCase						,							data_format=_UpperCAmelCase						,							**_UpperCAmelCase       )



       def 	lowercase__							(				self     :    List[Any]						,							_UpperCAmelCase     :    np.ndarray						,							_UpperCAmelCase     :    Union[int, float]						,							_UpperCAmelCase     :    Optional[Union[str, ChannelDimension]] = None						,							**_UpperCAmelCase     :    Optional[Any]						,							)					->		Optional[int]:


             '''simple docstring'''




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



       def 	lowercase__							(				self     :    Optional[Any]						,							_UpperCAmelCase     :    np.ndarray						,							_UpperCAmelCase     :    Union[float, List[float]]						,							_UpperCAmelCase     :    Union[float, List[float]]						,							_UpperCAmelCase     :    Optional[Union[str, ChannelDimension]] = None						,							**_UpperCAmelCase     :    Any						,							)					->		np.ndarray:


             '''simple docstring'''




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







       def 	lowercase__							(				self     :    List[str]						,							_UpperCAmelCase     :    ImageInput						,							_UpperCAmelCase     :    bool = None						,							_UpperCAmelCase     :    Dict[str, int] = None						,							_UpperCAmelCase     :    float = None						,							_UpperCAmelCase     :    PILImageResampling = None						,							_UpperCAmelCase     :    bool = None						,							_UpperCAmelCase     :    float = None						,							_UpperCAmelCase     :    bool = None						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							_UpperCAmelCase     :    Optional[Union[str, TensorType]] = None						,							_UpperCAmelCase     :    ChannelDimension = ChannelDimension.FIRST						,							**_UpperCAmelCase     :    List[str]						,							)					->		PIL.Image.Image:


             '''simple docstring'''




             UpperCAmelCase_     					=				do_resize if do_resize is not None else self.do_resize
             UpperCAmelCase_     					=				crop_pct if crop_pct is not None else self.crop_pct
             UpperCAmelCase_     					=				resample if resample is not None else self.resample
             UpperCAmelCase_     					=				do_rescale if do_rescale is not None else self.do_rescale
             UpperCAmelCase_     					=				rescale_factor if rescale_factor is not None else self.rescale_factor
             UpperCAmelCase_     					=				do_normalize if do_normalize is not None else self.do_normalize
             UpperCAmelCase_     					=				image_mean if image_mean is not None else self.image_mean
             UpperCAmelCase_     					=				image_std if image_std is not None else self.image_std

             UpperCAmelCase_     					=				size if size is not None else self.size
             UpperCAmelCase_     					=				get_size_dict(_UpperCAmelCase						,							default_to_square=_UpperCAmelCase       )

             UpperCAmelCase_     					=				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 or resample is None:
                   raise ValueError("Size and resample must be specified if do_resize is True."       )

             if do_resize and size["shortest_edge"] < 384 and crop_pct is None:
                   raise ValueError("crop_pct must be specified if size < 384."       )

             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_     					=				[to_numpy_array(_UpperCAmelCase       ) for image in images]

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

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

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

             UpperCAmelCase_     					=				[to_channel_dimension_format(_UpperCAmelCase						,							_UpperCAmelCase       ) for image in images]

             UpperCAmelCase_     					=				{"pixel_values": images}
             return BatchFeature(data=_UpperCAmelCase						,							tensor_type=_UpperCAmelCase       )










'''simple docstring'''





from math import factorial





def       __a      (  _UpperCamelCase:       int = 100       )		->					int:

     """simple docstring"""




     return sum(map(_UpperCamelCase   ,		str(factorial(_UpperCamelCase       )       )       )       )


if __name__ == "__main__":
   print(solution(int(input('''Enter the Number: ''').strip())))


