code: 
  
  import torch
  
  from diffusers import KDPMaAncestralDiscreteScheduler
  from diffusers.utils import torch_device
  
  from .test_schedulers import SchedulerCommonTest
  
  
  class _lowercase					(       _UpperCAmelCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							lowerCAmelCase__       =					(KDPMaAncestralDiscreteScheduler,)
  							lowerCAmelCase__       =					10
  
  
  
  							def     _UpperCAmelCase       (    self     ,   **UpperCAmelCase  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	{
  														    """num_train_timesteps""": 1100,
  														    """beta_start""": 0.0_001,
  														    """beta_end""": 0.02,
  														    """beta_schedule""": """linear""",
  														}
  
  														config.update(**UpperCAmelCase  )
  														return config
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														for timesteps in [10, 50, 100, 1000]:
  																					self.check_over_configs(num_train_timesteps=UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001]     ,   [0.0_002, 0.002, 0.02]  ):
  																					self.check_over_configs(beta_start=UpperCAmelCase     ,   beta_end=UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														for schedule in ["linear", "scaled_linear"]:
  																					self.check_over_configs(beta_schedule=UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														if torch_device == "mps":
  																					return
  														_lowercase				=	self.scheduler_classes[0]
  														_lowercase				=	self.get_scheduler_config()
  														_lowercase				=	scheduler_class(**UpperCAmelCase  )
  
  														scheduler.set_timesteps(self.num_inference_steps  )
  
  														_lowercase				=	torch.manual_seed(0  )
  
  														_lowercase				=	self.dummy_model()
  														_lowercase				=	self.dummy_sample_deter * scheduler.init_noise_sigma
  														_lowercase				=	sample.to(UpperCAmelCase  )
  
  														for i, t in enumerate(scheduler.timesteps  ):
  																					_lowercase				=	scheduler.scale_model_input(UpperCAmelCase     ,   UpperCAmelCase  )
  
  																					_lowercase				=	model(UpperCAmelCase     ,   UpperCAmelCase  )
  
  																					_lowercase				=	scheduler.step(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   generator=UpperCAmelCase  )
  																					_lowercase				=	output.prev_sample
  
  														_lowercase				=	torch.sum(torch.abs(UpperCAmelCase  )  )
  														_lowercase				=	torch.mean(torch.abs(UpperCAmelCase  )  )
  
  														assert abs(result_sum.item() - 13849.3877  ) < 1e-2
  														assert abs(result_mean.item() - 18.0_331  ) < 5e-3
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														for prediction_type in ["epsilon", "v_prediction"]:
  																					self.check_over_configs(prediction_type=UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														if torch_device == "mps":
  																					return
  														_lowercase				=	self.scheduler_classes[0]
  														_lowercase				=	self.get_scheduler_config(prediction_type="""v_prediction"""  )
  														_lowercase				=	scheduler_class(**UpperCAmelCase  )
  
  														scheduler.set_timesteps(self.num_inference_steps  )
  
  														_lowercase				=	self.dummy_model()
  														_lowercase				=	self.dummy_sample_deter * scheduler.init_noise_sigma
  														_lowercase				=	sample.to(UpperCAmelCase  )
  
  														_lowercase				=	torch.manual_seed(0  )
  
  														for i, t in enumerate(scheduler.timesteps  ):
  																					_lowercase				=	scheduler.scale_model_input(UpperCAmelCase     ,   UpperCAmelCase  )
  
  																					_lowercase				=	model(UpperCAmelCase     ,   UpperCAmelCase  )
  
  																					_lowercase				=	scheduler.step(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   generator=UpperCAmelCase  )
  																					_lowercase				=	output.prev_sample
  
  														_lowercase				=	torch.sum(torch.abs(UpperCAmelCase  )  )
  														_lowercase				=	torch.mean(torch.abs(UpperCAmelCase  )  )
  
  														assert abs(result_sum.item() - 328.9_970  ) < 1e-2
  														assert abs(result_mean.item() - 0.4_284  ) < 1e-3
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														if torch_device == "mps":
  																					return
  														_lowercase				=	self.scheduler_classes[0]
  														_lowercase				=	self.get_scheduler_config()
  														_lowercase				=	scheduler_class(**UpperCAmelCase  )
  
  														scheduler.set_timesteps(self.num_inference_steps     ,   device=UpperCAmelCase  )
  														_lowercase				=	torch.manual_seed(0  )
  
  														_lowercase				=	self.dummy_model()
  														_lowercase				=	self.dummy_sample_deter.to(UpperCAmelCase  ) * scheduler.init_noise_sigma
  
  														for t in scheduler.timesteps:
  																					_lowercase				=	scheduler.scale_model_input(UpperCAmelCase     ,   UpperCAmelCase  )
  
  																					_lowercase				=	model(UpperCAmelCase     ,   UpperCAmelCase  )
  
  																					_lowercase				=	scheduler.step(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   generator=UpperCAmelCase  )
  																					_lowercase				=	output.prev_sample
  
  														_lowercase				=	torch.sum(torch.abs(UpperCAmelCase  )  )
  														_lowercase				=	torch.mean(torch.abs(UpperCAmelCase  )  )
  
  														assert abs(result_sum.item() - 13849.3818  ) < 1e-1
  														assert abs(result_mean.item() - 18.0_331  ) < 1e-3
  
  
  
style_context: def 					__lowerCAmelCase			(  _A = 998_001					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	0
  							for i in range(999 ,99 ,-1					):  # 3 digit numbers range from 999 down to 100
  														for j in range(999 ,99 ,-1					):
  																					_lowercase				=	str(i * j					)
  																					if product_string == product_string[::-1] and i * j < n:
  																												_lowercase				=	max(_A ,i * j					)
  							return answer
  
  
  if __name__ == "__main__":
  				print(F'''{solution() = }''')
  
  
  