


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


__lowerCamelCase       				=	logging.get_logger(__name__)




class 							UpperCAmelCase ( _snake_case	):
 UpperCAmelCase				=				["pixel_values"]


 def __init__(			self       :  Optional[int] ,					__lowerCamelCase       :  bool = True ,					__lowerCamelCase       :  Optional[Dict[str, int]] = None ,					__lowerCamelCase       :  PILImageResampling = PILImageResampling.BILINEAR ,					__lowerCamelCase       :  bool = True ,					__lowerCamelCase       :  Union[int, float] = 1 / 2_5_5 ,					__lowerCamelCase       :  bool = True ,					__lowerCamelCase       :  Optional[Union[float, List[float]]] = None ,					__lowerCamelCase       :  Optional[Union[float, List[float]]] = None ,					**__lowerCamelCase       :  Optional[int] ,					):
    super().__init__(**__lowerCamelCase   )
    UpperCAmelCase__  :List[str]            =			size if size is not None else {'''height''': 2_2_4, '''width''': 2_2_4}
    UpperCAmelCase__  :List[str]            =			get_size_dict(__lowerCamelCase   )
    UpperCAmelCase__  :Optional[Any]            =			do_resize
    UpperCAmelCase__  :Union[str, Any]            =			do_rescale
    UpperCAmelCase__  :str            =			do_normalize
    UpperCAmelCase__  :List[Any]            =			size
    UpperCAmelCase__  :Any            =			resample
    UpperCAmelCase__  :Union[str, Any]            =			rescale_factor
    UpperCAmelCase__  :Optional[int]            =			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
    UpperCAmelCase__  :List[str]            =			image_std if image_std is not None else IMAGENET_STANDARD_STD


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Any ,					__lowerCamelCase       :  np.ndarray ,					__lowerCamelCase       :  Dict[str, int] ,					__lowerCamelCase       :  PILImageResampling = PILImageResampling.BILINEAR ,					__lowerCamelCase       :  Optional[Union[str, ChannelDimension]] = None ,					**__lowerCamelCase       :  Optional[Any] ,					):
    UpperCAmelCase__  :List[Any]            =			get_size_dict(__lowerCamelCase   )
    if "height" not in size or "width" not in size:
       raise ValueError(f'''The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}'''   )
    return resize(
        __lowerCamelCase ,					size=(size['''height'''], size['''width''']) ,					resample=__lowerCamelCase ,					data_format=__lowerCamelCase ,					**__lowerCamelCase   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any] ,					__lowerCamelCase       :  np.ndarray ,					__lowerCamelCase       :  float ,					__lowerCamelCase       :  Optional[Union[str, ChannelDimension]] = None ,					**__lowerCamelCase       :  List[str]   ):
    return rescale(__lowerCamelCase ,					scale=__lowerCamelCase ,					data_format=__lowerCamelCase ,					**__lowerCamelCase   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Tuple ,					__lowerCamelCase       :  np.ndarray ,					__lowerCamelCase       :  Union[float, List[float]] ,					__lowerCamelCase       :  Union[float, List[float]] ,					__lowerCamelCase       :  Optional[Union[str, ChannelDimension]] = None ,					**__lowerCamelCase       :  Union[str, Any] ,					):
    return normalize(__lowerCamelCase ,					mean=__lowerCamelCase ,					std=__lowerCamelCase ,					data_format=__lowerCamelCase ,					**__lowerCamelCase   )





 def 					__SCREAMING_SNAKE_CASE				(			self       :  Any ,					__lowerCamelCase       :  ImageInput ,					__lowerCamelCase       :  Optional[bool] = None ,					__lowerCamelCase       :  Dict[str, int] = None ,					__lowerCamelCase       :  PILImageResampling = None ,					__lowerCamelCase       :  Optional[bool] = None ,					__lowerCamelCase       :  Optional[float] = None ,					__lowerCamelCase       :  Optional[bool] = None ,					__lowerCamelCase       :  Optional[Union[float, List[float]]] = None ,					__lowerCamelCase       :  Optional[Union[float, List[float]]] = None ,					__lowerCamelCase       :  Optional[Union[str, TensorType]] = None ,					__lowerCamelCase       :  Union[str, ChannelDimension] = ChannelDimension.FIRST ,					**__lowerCamelCase       :  Optional[Any] ,					):
    UpperCAmelCase__  :Dict            =			do_resize if do_resize is not None else self.do_resize
    UpperCAmelCase__  :str            =			do_rescale if do_rescale is not None else self.do_rescale
    UpperCAmelCase__  :Tuple            =			do_normalize if do_normalize is not None else self.do_normalize
    UpperCAmelCase__  :Any            =			resample if resample is not None else self.resample
    UpperCAmelCase__  :Optional[Any]            =			rescale_factor if rescale_factor is not None else self.rescale_factor
    UpperCAmelCase__  :Union[str, Any]            =			image_mean if image_mean is not None else self.image_mean
    UpperCAmelCase__  :Optional[Any]            =			image_std if image_std is not None else self.image_std

    UpperCAmelCase__  :Optional[int]            =			size if size is not None else self.size
    UpperCAmelCase__  :int            =			get_size_dict(__lowerCamelCase   )

    UpperCAmelCase__  :Optional[int]            =			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_resize and size is None:
       raise ValueError('''Size must be specified if do_resize is True.'''   )

    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.
    UpperCAmelCase__  :Optional[int]            =			[to_numpy_array(__lowerCamelCase   ) for image in images]

    if do_resize:
       UpperCAmelCase__  :Any            =			[self.resize(image=__lowerCamelCase ,					size=__lowerCamelCase ,					resample=__lowerCamelCase   ) for image in images]

    if do_rescale:
       UpperCAmelCase__  :Any            =			[self.rescale(image=__lowerCamelCase ,					scale=__lowerCamelCase   ) for image in images]

    if do_normalize:
       UpperCAmelCase__  :List[Any]            =			[self.normalize(image=__lowerCamelCase ,					mean=__lowerCamelCase ,					std=__lowerCamelCase   ) for image in images]

    UpperCAmelCase__  :Any            =			[to_channel_dimension_format(__lowerCamelCase ,					__lowerCamelCase   ) for image in images]

    UpperCAmelCase__  :List[str]            =			{'''pixel_values''': images}
    return BatchFeature(data=__lowerCamelCase ,					tensor_type=__lowerCamelCase   )







'''simple docstring'''





def 					a__    (				UpperCamelCase_	:			int = 100	):
   UpperCAmelCase__  :List[str]            =			1
   UpperCAmelCase__  :Dict            =			0
   for i in range(1,      num + 1	):
      fact *= i

   for j in str(UpperCamelCase_	):
      result += int(UpperCamelCase_	)

   return result


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



