





"""simple docstring"""
from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
  import PIL

if is_torch_available():
  import torch


lowerCamelCase_								=		logging.get_logger(__name__)






class 					_SCREAMING_SNAKE_CASE(   A  ):
       SCREAMING_SNAKE_CASE_   :      Union[str, Any]							=  ['''pixel_values''']




       def __init__(						self		,SCREAMING_SNAKE_CASE__ = True		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = PILImageResampling.BILINEAR		,SCREAMING_SNAKE_CASE__ = True		,SCREAMING_SNAKE_CASE__ = 1 / 2_55		,SCREAMING_SNAKE_CASE__ = True		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = True		,**SCREAMING_SNAKE_CASE__		,)			->      None:





             """simple docstring"""






             super().__init__(**SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :int						=  size if size is not None else {'''shortest_edge''': 2_24}
             __SCREAMING_SNAKE_CASE   :Optional[int]						=  get_size_dict(SCREAMING_SNAKE_CASE__		,default_to_square=SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :str						=  crop_size if crop_size is not None else {'''height''': 2_56, '''width''': 2_56}
             __SCREAMING_SNAKE_CASE   :Tuple						=  get_size_dict(SCREAMING_SNAKE_CASE__		,param_name='''crop_size'''							)

             __SCREAMING_SNAKE_CASE   :Tuple						=  do_resize
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  size
             __SCREAMING_SNAKE_CASE   :List[str]						=  resample
             __SCREAMING_SNAKE_CASE   :Dict						=  do_rescale
             __SCREAMING_SNAKE_CASE   :int						=  rescale_factor
             __SCREAMING_SNAKE_CASE   :str						=  do_center_crop
             __SCREAMING_SNAKE_CASE   :str						=  crop_size
             __SCREAMING_SNAKE_CASE   :Tuple						=  do_flip_channel_order




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = PIL.Image.BILINEAR		,SCREAMING_SNAKE_CASE__ = None		,**SCREAMING_SNAKE_CASE__		,)			->      np.ndarray:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[int]						=  get_size_dict(SCREAMING_SNAKE_CASE__		,default_to_square=SCREAMING_SNAKE_CASE__							)
             if "shortest_edge" not in size:
                   raise ValueError(f'''The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}'''							)
             __SCREAMING_SNAKE_CASE   :Optional[int]						=  get_resize_output_image_size(SCREAMING_SNAKE_CASE__		,size=size['''shortest_edge''']		,default_to_square=SCREAMING_SNAKE_CASE__							)
             return resize(SCREAMING_SNAKE_CASE__		,size=SCREAMING_SNAKE_CASE__		,resample=SCREAMING_SNAKE_CASE__		,data_format=SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None		,**SCREAMING_SNAKE_CASE__		,)			->      np.ndarray:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[int]						=  get_size_dict(SCREAMING_SNAKE_CASE__							)
             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 center_crop(SCREAMING_SNAKE_CASE__		,size=(size['''height'''], size['''width'''])		,data_format=SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None		,**SCREAMING_SNAKE_CASE__		,)			->      str:





             """simple docstring"""






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




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None							)			->      np.ndarray:





             """simple docstring"""






             return flip_channel_order(SCREAMING_SNAKE_CASE__		,data_format=SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = ChannelDimension.FIRST		,**SCREAMING_SNAKE_CASE__		,)			->      PIL.Image.Image:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Tuple						=  do_resize if do_resize is not None else self.do_resize
             __SCREAMING_SNAKE_CASE   :List[Any]						=  resample if resample is not None else self.resample
             __SCREAMING_SNAKE_CASE   :str						=  do_rescale if do_rescale is not None else self.do_rescale
             __SCREAMING_SNAKE_CASE   :Dict						=  rescale_factor if rescale_factor is not None else self.rescale_factor
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  do_center_crop if do_center_crop is not None else self.do_center_crop
             __SCREAMING_SNAKE_CASE   :List[Any]						=  (
                 do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
             )

             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  size if size is not None else self.size
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  get_size_dict(SCREAMING_SNAKE_CASE__		,default_to_square=SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :List[Any]						=  crop_size if crop_size is not None else self.crop_size
             __SCREAMING_SNAKE_CASE   :Dict						=  get_size_dict(SCREAMING_SNAKE_CASE__		,param_name='''crop_size'''							)

             __SCREAMING_SNAKE_CASE   :Tuple						=  make_list_of_images(SCREAMING_SNAKE_CASE__							)

             if not valid_images(SCREAMING_SNAKE_CASE__							):
                   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.'''							)

             if do_center_crop and crop_size is None:
                   raise ValueError('''Crop size must be specified if do_center_crop is True.'''							)

             # All transformations expect numpy arrays.
             __SCREAMING_SNAKE_CASE   :str						=  [to_numpy_array(SCREAMING_SNAKE_CASE__							) for image in images]

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

             if do_center_crop:
                   __SCREAMING_SNAKE_CASE   :str						=  [self.center_crop(image=SCREAMING_SNAKE_CASE__		,size=SCREAMING_SNAKE_CASE__							) for image in images]

             if do_rescale:
                   __SCREAMING_SNAKE_CASE   :Dict						=  [self.rescale(image=SCREAMING_SNAKE_CASE__		,scale=SCREAMING_SNAKE_CASE__							) for image in images]

             # the pretrained checkpoints assume images are BGR, not RGB
             if do_flip_channel_order:
                   __SCREAMING_SNAKE_CASE   :str						=  [self.flip_channel_order(image=SCREAMING_SNAKE_CASE__							) for image in images]

             __SCREAMING_SNAKE_CASE   :List[str]						=  [to_channel_dimension_format(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							) for image in images]

             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  {'''pixel_values''': images}
             return BatchFeature(data=SCREAMING_SNAKE_CASE__		,tensor_type=SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None							)			->      str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  outputs.logits

             # Resize logits and compute semantic segmentation maps
             if target_sizes is not None:
                   if len(SCREAMING_SNAKE_CASE__							) != len(SCREAMING_SNAKE_CASE__							):
                         raise ValueError(
                             '''Make sure that you pass in as many target sizes as the batch dimension of the logits'''							)

                   if is_torch_tensor(SCREAMING_SNAKE_CASE__							):
                         __SCREAMING_SNAKE_CASE   :int						=  target_sizes.numpy()

                   __SCREAMING_SNAKE_CASE   :List[str]						=  []

                   for idx in range(len(SCREAMING_SNAKE_CASE__							)							):
                         __SCREAMING_SNAKE_CASE   :Optional[int]						=  torch.nn.functional.interpolate(
                             logits[idx].unsqueeze(dim=0							)		,size=target_sizes[idx]		,mode='''bilinear'''		,align_corners=SCREAMING_SNAKE_CASE__							)
                         __SCREAMING_SNAKE_CASE   :int						=  resized_logits[0].argmax(dim=0							)
                         semantic_segmentation.append(SCREAMING_SNAKE_CASE__							)
             else:
                   __SCREAMING_SNAKE_CASE   :Optional[Any]						=  logits.argmax(dim=1							)
                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]							)]

             return semantic_segmentation






"""simple docstring"""
def      __lowerCamelCase   (							a_     :		Union[str, Any]							)			->      Optional[int]:
      __SCREAMING_SNAKE_CASE   :List[str]						=  1
      __SCREAMING_SNAKE_CASE   :Dict						=  2
      while i * i <= n:
            __SCREAMING_SNAKE_CASE   :Tuple						=  0
            while n % i == 0:
                  n //= i
                  multiplicity += 1
            n_divisors *= multiplicity + 1
            i += 1
      if n > 1:
            n_divisors *= 2
      return n_divisors



def      __lowerCamelCase   (							)			->      int:
      __SCREAMING_SNAKE_CASE   :Dict						=  1
      __SCREAMING_SNAKE_CASE   :Dict						=  1

      while True:
            i += 1
            t_num += i

            if count_divisors(a_							) > 5_00:
                  break

      return t_num


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