





"""simple docstring"""



from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


a_			=      logging.get_logger(__name__)






class 		__snake_case (		_snake_case					):





 """simple docstring"""


 _lowerCamelCase				=					["""pixel_values"""]

 def __init__(   self ,						__lowerCamelCase = True ,						__lowerCamelCase = 32 ,						__lowerCamelCase=PILImageResampling.BILINEAR ,						__lowerCamelCase = True ,						**__lowerCamelCase ,						):



     '''simple docstring'''




     __A   :						Any									=					do_resize
     __A   :						Any									=					do_rescale
     __A   :						Dict									=					size_divisor
     __A   :						List[str]									=					resample
     super().__init__(**UpperCamelCase__  )

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase = None ,						**__lowerCamelCase  ):



     '''simple docstring'''




     __A			,	__A   :						str									=					get_image_size(UpperCamelCase__  )
     # Rounds the height and width down to the closest multiple of size_divisor
     __A   :						int									=					height // size_divisor * size_divisor
     __A   :						List[Any]									=					width // size_divisor * size_divisor
     __A   :						int									=					resize(UpperCamelCase__ ,						(new_h, new_w) ,						resample=UpperCamelCase__ ,						data_format=UpperCamelCase__ ,						**UpperCamelCase__  )
     return image

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase = None ,						**__lowerCamelCase  ):



     '''simple docstring'''




     return rescale(image=UpperCamelCase__ ,						scale=UpperCamelCase__ ,						data_format=UpperCamelCase__ ,						**UpperCamelCase__  )







 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase = None ,						__lowerCamelCase = None ,						__lowerCamelCase=None ,						__lowerCamelCase = None ,						__lowerCamelCase = None ,						__lowerCamelCase = ChannelDimension.FIRST ,						**__lowerCamelCase ,						):



     '''simple docstring'''




     __A   :						List[str]									=					do_resize if do_resize is not None else self.do_resize
     __A   :						Union[str, Any]									=					do_rescale if do_rescale is not None else self.do_rescale
     __A   :						Tuple									=					size_divisor if size_divisor is not None else self.size_divisor
     __A   :						int									=					resample if resample is not None else self.resample

     if do_resize and size_divisor is None:
         raise ValueError('''size_divisor is required for resizing'''  )

     __A   :						Union[str, Any]									=					make_list_of_images(UpperCamelCase__  )

     if not valid_images(UpperCamelCase__  ):
         raise ValueError('''Invalid image(s)'''  )

     # All transformations expect numpy arrays.
     __A   :						Union[str, Any]									=					[to_numpy_array(UpperCamelCase__  ) for img in images]

     if do_resize:
         __A   :						Union[str, Any]									=					[self.resize(UpperCamelCase__ ,						size_divisor=UpperCamelCase__ ,						resample=UpperCamelCase__  ) for image in images]

     if do_rescale:
         __A   :						Union[str, Any]									=					[self.rescale(UpperCamelCase__ ,						scale=1 / 255  ) for image in images]

     __A   :						Any									=					[to_channel_dimension_format(UpperCamelCase__ ,						UpperCamelCase__  ) for image in images]

     __A   :						Tuple									=					{'''pixel_values''': images}
     return BatchFeature(data=UpperCamelCase__ ,						tensor_type=UpperCamelCase__  )











"""simple docstring"""



def 		__lowercase					(       )       ->Tuple:



    '''simple docstring'''







    __A   :						str									=					[]
    __A   :						List[Any]									=					1

    while len(snake_case_						) < 1e6:
        constant.append(str(snake_case_						)						)
        i += 1

    __A   :						Any									=					''''''.join(snake_case_						)

    return (
        int(constant[0]						)
        * int(constant[9]						)
        * int(constant[99]						)
        * int(constant[999]						)
        * int(constant[9999]						)
        * int(constant[99999]						)
        * int(constant[999999]						)
    )


if __name__ == "__main__":
       print(solution())




