






def 			__lowerCamelCase     (						snake_case__ = 99_80_01						)				->    int:






						"""simple docstring"""





						for number in range(n - 1			,99_99			,-1						):
												_SCREAMING_SNAKE_CASE       =    str(a_						)

												# checks whether 'str_number' is a palindrome.
												if str_number == str_number[::-1]:
																		_SCREAMING_SNAKE_CASE       =    9_99

																		# 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() = }")






'''simple docstring'''





import torch
import torch.nn.functional as F

from diffusers import VQDiffusionScheduler

from .test_schedulers import SchedulerCommonTest


class 							_lowerCAmelCase	(  __A							):


 """simple docstring"""

 lowerCamelCase									=     (VQDiffusionScheduler,)







 def       UpperCAmelCase_       (      self					,    **_lowerCamelCase  )    ->    Any:
    A_  :		List[Any]						=					{
        """num_vec_classes""": 4097,
        """num_train_timesteps""": 100,
    }

    config.update(**_lowerCamelCase  )
    return config







 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    Tuple:
    A_  :		Tuple						=					4
    A_  :		List[str]						=					8
    A_  :		Dict						=					8

    A_  :		int						=					torch.randint(0					,    _lowerCamelCase					,    (batch_size, height * width)  )

    return sample







 @property
 def       UpperCAmelCase_       (      self  )    ->    Union[str, Any]:
    assert False







 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    List[str]:
    def model(_lowerCamelCase					,    _lowerCamelCase					,    *_lowerCamelCase  ):
       A_						,  A_  :		List[Any]						=					sample.shape
       A_  :		int						=					torch.rand((batch_size, num_vec_classes - 1, num_latent_pixels)  )
       A_  :		Optional[int]						=					F.log_softmax(logits.double()					,    dim=1  ).float()
       return return_value

    return model







 def       UpperCAmelCase_       (      self  )    ->    Tuple:
    for timesteps in [2, 5, 100, 1000]:
       self.check_over_configs(num_train_timesteps=_lowerCamelCase  )







 def       UpperCAmelCase_       (      self  )    ->    Tuple:
    for num_vec_classes in [5, 100, 1000, 4000]:
       self.check_over_configs(num_vec_classes=_lowerCamelCase  )







 def       UpperCAmelCase_       (      self  )    ->    int:
    for t in [0, 50, 99]:
       self.check_over_forward(time_step=_lowerCamelCase  )







 def       UpperCAmelCase_       (      self  )    ->    Optional[int]:
    pass
