






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


a__       =     logging.get_logger(__name__)


class    _lowerCAmelCase			(		lowercase_		):



				"""simple docstring"""



				_lowercase				:   Optional[Any]      =  ['''pixel_values''']



				def __init__(      self    :    int			,		UpperCamelCase__    :    bool = True			,		UpperCamelCase__    :    Optional[Dict[str, int]] = None			,		UpperCamelCase__    :    PILImageResampling = PILImageResampling.BILINEAR			,		UpperCamelCase__    :    bool = True			,		UpperCamelCase__    :    Dict[str, int] = None			,		UpperCamelCase__    :    bool = True			,		UpperCamelCase__    :    Union[int, float] = 1 / 2_5_5			,		UpperCamelCase__    :    bool = True			,		UpperCamelCase__    :    Optional[Union[float, List[float]]] = None			,		UpperCamelCase__    :    Optional[Union[float, List[float]]] = None			,		**UpperCamelCase__    :    Any			,		):






											'''simple docstring'''







											super().__init__(**UpperCamelCase__)
											snake_case__	  =       size if size is not None else {"""shortest_edge""": 2_5_6}
											snake_case__	  =       get_size_dict(UpperCamelCase__			,		default_to_square=UpperCamelCase__)
											snake_case__	  =       crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
											snake_case__	  =       get_size_dict(UpperCamelCase__)
											snake_case__	  =       do_resize
											snake_case__	  =       size
											snake_case__	  =       resample
											snake_case__	  =       do_center_crop
											snake_case__	  =       crop_size
											snake_case__	  =       do_rescale
											snake_case__	  =       rescale_factor
											snake_case__	  =       do_normalize
											snake_case__	  =       image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
											snake_case__	  =       image_std if image_std is not None else IMAGENET_STANDARD_STD



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






											'''simple docstring'''







											snake_case__	  =       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()}''')
											snake_case__	  =       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 					__magic_name__							(      self    :    Dict			,		UpperCamelCase__    :    np.ndarray			,		UpperCamelCase__    :    Dict[str, int]			,		UpperCamelCase__    :    Optional[Union[str, ChannelDimension]] = None			,		**UpperCamelCase__    :    Optional[int]			,		):






											'''simple docstring'''







											snake_case__	  =       get_size_dict(UpperCamelCase__)
											return center_crop(UpperCamelCase__			,		size=(size["""height"""], size["""width"""])			,		data_format=UpperCamelCase__			,		**UpperCamelCase__)



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






											'''simple docstring'''







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



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






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    Dict			,		UpperCamelCase__    :    ImageInput			,		UpperCamelCase__    :    Optional[bool] = None			,		UpperCamelCase__    :    Dict[str, int] = None			,		UpperCamelCase__    :    PILImageResampling = None			,		UpperCamelCase__    :    bool = None			,		UpperCamelCase__    :    Dict[str, int] = None			,		UpperCamelCase__    :    Optional[bool] = None			,		UpperCamelCase__    :    Optional[float] = None			,		UpperCamelCase__    :    Optional[bool] = None			,		UpperCamelCase__    :    Optional[Union[float, List[float]]] = None			,		UpperCamelCase__    :    Optional[Union[float, List[float]]] = None			,		UpperCamelCase__    :    Optional[Union[str, TensorType]] = None			,		UpperCamelCase__    :    Union[str, ChannelDimension] = ChannelDimension.FIRST			,		**UpperCamelCase__    :    Any			,		):






											'''simple docstring'''







											snake_case__	  =       do_resize if do_resize is not None else self.do_resize
											snake_case__	  =       size if size is not None else self.size
											snake_case__	  =       get_size_dict(UpperCamelCase__			,		default_to_square=UpperCamelCase__)
											snake_case__	  =       resample if resample is not None else self.resample
											snake_case__	  =       do_center_crop if do_center_crop is not None else self.do_center_crop
											snake_case__	  =       crop_size if crop_size is not None else self.crop_size
											snake_case__	  =       get_size_dict(UpperCamelCase__)
											snake_case__	  =       do_rescale if do_rescale is not None else self.do_rescale
											snake_case__	  =       rescale_factor if rescale_factor is not None else self.rescale_factor
											snake_case__	  =       do_normalize if do_normalize is not None else self.do_normalize
											snake_case__	  =       image_mean if image_mean is not None else self.image_mean
											snake_case__	  =       image_std if image_std is not None else self.image_std

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

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

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

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

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

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

											snake_case__	  =       [to_channel_dimension_format(UpperCamelCase__			,		UpperCamelCase__) for image in images]

											snake_case__	  =       {"""pixel_values""": images}
											return BatchFeature(data=UpperCamelCase__			,		tensor_type=UpperCamelCase__)








from math import factorial

a__       =     {str(digit): factorial(digit) for digit in range(1_0)}

def _UpperCAmelCase   (	a						:	int ):
							if not isinstance(a  ,					a ):
														raise TypeError("""Parameter number must be int""" )

							if number < 0:
														raise ValueError("""Parameter number must be greater than or equal to 0""" )

							# Converts number in string to iterate on its digits and adds its factorial.
							return sum(DIGIT_FACTORIAL[digit] for digit in str(a ) )

def _UpperCAmelCase   (	a						:	int = 60  ,					a						:	int = 100_0000 ):

							if not isinstance(a  ,					a ) or not isinstance(a  ,					a ):
														raise TypeError("""Parameters chain_length and number_limit must be int""" )

							if chain_length <= 0 or number_limit <= 0:
														raise ValueError(
														    """Parameters chain_length and number_limit must be greater than 0""" )

							# the counter for the chains with the exact desired length
							snake_case__	  =       0
							# the cached sizes of the previous chains
							snake_case__	  =       {}

							for start_chain_element in range(1  ,					a ):
														# The temporary set will contain the elements of the chain
														snake_case__	  =       set()
														snake_case__	  =       0

														# Stop computing the chain when you find a cached size, a repeating item or the
														# length is greater then the desired one.
														snake_case__	  =       start_chain_element
														while (
														    chain_element not in chain_sets_lengths
														    and chain_element not in chain_set
														    and chain_set_length <= chain_length
														):
																					chain_set.add(a )
																					chain_set_length += 1
																					snake_case__	  =       digit_factorial_sum(a )

														if chain_element in chain_sets_lengths:
																					chain_set_length += chain_sets_lengths[chain_element]

														snake_case__	  =       chain_set_length

														# If chain contains the exact amount of elements increase the counter
														if chain_set_length == chain_length:
																					chains_counter += 1

							return chains_counter


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(F'''{solution()}''')
