

"""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,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


SCREAMING_SNAKE_CASE_					:	Dict							  =						logging.get_logger(__name__)


if is_vision_available():
 import PIL



class 					a						(       _lowerCamelCase				):



    """simple docstring"""



    UpperCAmelCase						 =					["pixel_values"]

    def __init__(     self: str    ,						UpperCamelCase: bool = True    ,						UpperCamelCase: Dict[str, int] = None    ,						UpperCamelCase: PILImageResampling = PILImageResampling.BICUBIC    ,						UpperCamelCase: bool = True    ,						UpperCamelCase: Dict[str, int] = None    ,						UpperCamelCase: bool = True    ,						UpperCamelCase: Union[int, float] = 1 / 2_55    ,						UpperCamelCase: bool = True    ,						UpperCamelCase: Optional[Union[float, List[float]]] = None    ,						UpperCamelCase: Optional[Union[float, List[float]]] = None    ,						UpperCamelCase: bool = True    ,						**UpperCamelCase: str    ,						):






         """simple docstring"""


         super().__init__(**UpperCamelCase       )
         A__										=  size if size is not None else {"""shortest_edge""": 2_24}
         A__										=  get_size_dict(UpperCamelCase    ,						default_to_square=UpperCamelCase       )
         A__										=  crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24}
         A__										=  get_size_dict(UpperCamelCase    ,						default_to_square=UpperCamelCase    ,						param_name="""crop_size"""       )

         A__										=  do_resize
         A__										=  size
         A__										=  resample
         A__										=  do_center_crop
         A__										=  crop_size
         A__										=  do_rescale
         A__										=  rescale_factor
         A__										=  do_normalize
         A__										=  image_mean if image_mean is not None else OPENAI_CLIP_MEAN
         A__										=  image_std if image_std is not None else OPENAI_CLIP_STD
         A__										=  do_convert_rgb

    def 				UpperCamelCase	(     self: Optional[int]    ,						UpperCamelCase: np.ndarray    ,						UpperCamelCase: Dict[str, int]    ,						UpperCamelCase: PILImageResampling = PILImageResampling.BICUBIC    ,						UpperCamelCase: Optional[Union[str, ChannelDimension]] = None    ,						**UpperCamelCase: str    ,						):






         """simple docstring"""


         A__										=  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()}"""       )
         A__										=  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 				UpperCamelCase	(     self: List[Any]    ,						UpperCamelCase: np.ndarray    ,						UpperCamelCase: Dict[str, int]    ,						UpperCamelCase: Optional[Union[str, ChannelDimension]] = None    ,						**UpperCamelCase: List[str]    ,						):






         """simple docstring"""


         A__										=  get_size_dict(UpperCamelCase       )
         if "height" not in size or "width" not in size:
              raise ValueError(f"""The `size` parameter must contain the keys (height, width). Got {size.keys()}"""       )
         return center_crop(UpperCamelCase    ,						size=(size["""height"""], size["""width"""])    ,						data_format=UpperCamelCase    ,						**UpperCamelCase       )

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






         """simple docstring"""


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

    def 				UpperCamelCase	(     self: str    ,						UpperCamelCase: np.ndarray    ,						UpperCamelCase: Union[float, List[float]]    ,						UpperCamelCase: Union[float, List[float]]    ,						UpperCamelCase: Optional[Union[str, ChannelDimension]] = None    ,						**UpperCamelCase: int    ,						):






         """simple docstring"""


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





    def 				UpperCamelCase	(     self: Any    ,						UpperCamelCase: ImageInput    ,						UpperCamelCase: bool = None    ,						UpperCamelCase: Dict[str, int] = None    ,						UpperCamelCase: PILImageResampling = None    ,						UpperCamelCase: bool = None    ,						UpperCamelCase: int = 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: bool = None    ,						UpperCamelCase: Optional[Union[str, TensorType]] = None    ,						UpperCamelCase: Optional[ChannelDimension] = ChannelDimension.FIRST    ,						**UpperCamelCase: Dict    ,						):






         """simple docstring"""


         A__										=  do_resize if do_resize is not None else self.do_resize
         A__										=  size if size is not None else self.size
         A__										=  get_size_dict(UpperCamelCase    ,						param_name="""size"""    ,						default_to_square=UpperCamelCase       )
         A__										=  resample if resample is not None else self.resample
         A__										=  do_center_crop if do_center_crop is not None else self.do_center_crop
         A__										=  crop_size if crop_size is not None else self.crop_size
         A__										=  get_size_dict(UpperCamelCase    ,						param_name="""crop_size"""    ,						default_to_square=UpperCamelCase       )
         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_normalize if do_normalize is not None else self.do_normalize
         A__										=  image_mean if image_mean is not None else self.image_mean
         A__										=  image_std if image_std is not None else self.image_std
         A__										=  do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

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

         # PIL RGBA images are converted to RGB
         if do_convert_rgb:
              A__										=  [convert_to_rgb(UpperCamelCase       ) for image in images]

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

         if do_resize:
              A__										=  [self.resize(image=UpperCamelCase    ,						size=UpperCamelCase    ,						resample=UpperCamelCase       ) for image in images]

         if do_center_crop:
              A__										=  [self.center_crop(image=UpperCamelCase    ,						size=UpperCamelCase       ) for image in images]

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

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

         A__										=  [to_channel_dimension_format(UpperCamelCase    ,						UpperCamelCase       ) for image in images]

         A__										=  {"""pixel_values""": images}
         return BatchFeature(data=UpperCamelCase    ,						tensor_type=UpperCamelCase       )









"""simple docstring"""



def  _snake_case     (    UpperCAmelCase_  :					int			):
     A__										=  1
     for i in range(1					,   num + 1			):
          fact *= i
     return fact





def  _snake_case     (    UpperCAmelCase_  :					int			):
     A__										=  0
     while number > 0:
          A__										=  number % 10
          sum_of_digits += last_digit
          A__										=  number // 10  # Removing the last_digit from the given number
     return sum_of_digits





def  _snake_case     (    UpperCAmelCase_  :					int = 100			):
     A__										=  factorial(UpperCAmelCase_			)
     A__										=  split_and_add(UpperCAmelCase_			)
     return result


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






