




import unittest

import numpy as np
import PIL
import torch

from diffusers.image_processor import VaeImageProcessor


class        __SCREAMING_SNAKE_CASE							(	unittest.TestCase						):

					@property
					def 			lowercase_							(       self      ):







						'''simple docstring'''




						lowerCamelCase_							:	List[Any]							     =							1
						lowerCamelCase_							:	Tuple							     =							3
						lowerCamelCase_							:	int							     =							8
						lowerCamelCase_							:	Optional[int]							     =							8

						lowerCamelCase_							:	Any							     =							torch.rand((batch_size, num_channels, height, width)      )

						return sample

					def 			lowercase_							(       self				, __lowercase      ):







						'''simple docstring'''




						if isinstance(image[0]				, PIL.Image.Image      ):
							return np.stack([np.array(__lowercase      ) for i in image]				, axis=0      )
						elif isinstance(__lowercase				, torch.Tensor      ):
							return image.cpu().numpy().transpose(0				, 2				, 3				, 1      )
						return image

					def 			lowercase_							(       self      ):







						'''simple docstring'''




						lowerCamelCase_							:	int							     =							VaeImageProcessor(do_resize=__lowercase				, do_normalize=__lowercase      )

						lowerCamelCase_							:	Union[str, Any]							     =							self.dummy_sample
						lowerCamelCase_							:	Tuple							     =							self.to_np(__lowercase      )

						for output_type in ["pt", "np", "pil"]:
							lowerCamelCase_							:	List[str]							     =							image_processor.postprocess(
							    image_processor.preprocess(__lowercase      )				, output_type=__lowercase				, )
							lowerCamelCase_							:	List[Any]							     =							self.to_np(__lowercase      )
							lowerCamelCase_							:	Optional[Any]							     =							(input_np * 255).round() if output_type == 'pil' else input_np
							assert (
							    np.abs(in_np - out_np      ).max() < 1E-6
							), f"decoded output does not match input for output_type {output_type}"

					def 			lowercase_							(       self      ):







						'''simple docstring'''




						lowerCamelCase_							:	List[str]							     =							VaeImageProcessor(do_resize=__lowercase				, do_normalize=__lowercase      )
						lowerCamelCase_							:	Union[str, Any]							     =							self.dummy_sample.cpu().numpy().transpose(0				, 2				, 3				, 1      )

						for output_type in ["pt", "np", "pil"]:
							lowerCamelCase_							:	List[str]							     =							image_processor.postprocess(image_processor.preprocess(__lowercase      )				, output_type=__lowercase      )

							lowerCamelCase_							:	Any							     =							self.to_np(__lowercase      )
							lowerCamelCase_							:	Dict							     =							(input_np * 255).round() if output_type == 'pil' else input_np
							assert (
							    np.abs(in_np - out_np      ).max() < 1E-6
							), f"decoded output does not match input for output_type {output_type}"

					def 			lowercase_							(       self      ):







						'''simple docstring'''




						lowerCamelCase_							:	List[str]							     =							VaeImageProcessor(do_resize=__lowercase				, do_normalize=__lowercase      )

						lowerCamelCase_							:	Union[str, Any]							     =							self.dummy_sample.cpu().numpy().transpose(0				, 2				, 3				, 1      )
						lowerCamelCase_							:	Tuple							     =							image_processor.numpy_to_pil(__lowercase      )

						for output_type in ["pt", "np", "pil"]:
							lowerCamelCase_							:	int							     =							image_processor.postprocess(image_processor.preprocess(__lowercase      )				, output_type=__lowercase      )
							for i, o in zip(__lowercase				, __lowercase      ):
								lowerCamelCase_							:	Tuple							     =							np.array(__lowercase      )
								lowerCamelCase_							:	Optional[Any]							     =							self.to_np(__lowercase      ) if output_type == 'pil' else (self.to_np(__lowercase      ) * 255).round()
								assert (
								    np.abs(in_np - out_np      ).max() < 1E-6
								), f"decoded output does not match input for output_type {output_type}"

					def 			lowercase_							(       self      ):







						'''simple docstring'''




						lowerCamelCase_							:	Optional[int]							     =							VaeImageProcessor(do_resize=__lowercase				, do_normalize=__lowercase      )

						lowerCamelCase_							:	Union[str, Any]							     =							self.dummy_sample
						lowerCamelCase_							:	Dict							     =							input_pt_ad.squeeze(0      )

						lowerCamelCase_							:	str							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )
						lowerCamelCase_							:	Dict							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )

						lowerCamelCase_							:	Union[str, Any]							     =							self.to_np(self.dummy_sample      )
						lowerCamelCase_							:	Any							     =							input_np_ad.squeeze(0      )

						lowerCamelCase_							:	Any							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )
						lowerCamelCase_							:	Any							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )

						assert np.abs(out_pt_ad - out_pt_ad      ).max() < 1E-6
						assert np.abs(out_np_ad - out_np_ad      ).max() < 1E-6





					def 			lowercase_							(       self      ):







						'''simple docstring'''




						lowerCamelCase_							:	List[str]							     =							VaeImageProcessor(do_resize=__lowercase				, do_normalize=__lowercase      )

						lowerCamelCase_							:	Dict							     =							self.dummy_sample
						lowerCamelCase_							:	Tuple							     =							list(__lowercase      )

						lowerCamelCase_							:	int							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )

						lowerCamelCase_							:	Optional[int]							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )

						lowerCamelCase_							:	Optional[int]							     =							self.to_np(self.dummy_sample      )
						list(__lowercase      )

						lowerCamelCase_							:	Optional[Any]							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )

						lowerCamelCase_							:	Dict							     =							image_processor.postprocess(
						    image_processor.preprocess(__lowercase      )				, output_type='np'				, )

						assert np.abs(out_pt_ad - out_pt_list      ).max() < 1E-6
						assert np.abs(out_np_ad - out_np_list      ).max() < 1E-6






def       snake_case      (							A = 998001    )							->							int:




	'''simple docstring'''


	for number in range(n - 1		,     9999		,     -1    ):
		lowerCamelCase_							:	Tuple							     =							str(A    )

		# checks whether 'str_number' is a palindrome.
		if str_number == str_number[::-1]:
			lowerCamelCase_							:	Tuple							     =							999

			# if 'number' is a product of two 3-digit numbers
			# then number is the answer otherwise fetch next number.
			while divisor != 99:
				if (number % divisor == 0) and (len(str(number // divisor    )    ) == 3.0):
					return number
				divisor -= 1
	raise ValueError('That number is larger than our acceptable range.'    )


if __name__ == "__main__":
							print(F'{solution() = }')
