
'''simple docstring'''



def A				(__lowerCamelCase				:List[str]=28123		):
						_lowerCAmelCase  						=			[1] * (limit + 1)

						for i in range(2			,     int(limit**0.5		) + 1		):
												sum_divs[i * i] += i
												for k in range(i + 1			,     limit // i + 1		):
																		sum_divs[k * i] += k + i

						_lowerCAmelCase  						=			set()
						_lowerCAmelCase  						=			0

						for n in range(1			,     limit + 1		):
												if sum_divs[n] > n:
																		abundants.add(__lowerCamelCase		)

												if not any((n - a in abundants) for a in abundants		):
																		res += n

						return res


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


'''simple docstring'''



from typing import List, Optional, Tuple, Union

import torch

from ...schedulers import DDIMScheduler
from ...utils import randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput




class   UpperCAmelCase_					(		_SCREAMING_SNAKE_CASE			):






						'''simple docstring'''






						def __init__( self   ,       _lowercase   ,       _lowercase				):

												"""simple docstring"""



												super().__init__()

												# make sure scheduler can always be converted to DDIM
												_lowerCAmelCase  						=			DDIMScheduler.from_config(scheduler.config				)

												self.register_modules(unet=_lowercase   ,       scheduler=_lowercase				)




						@torch.no_grad()
						def __call__( self   ,       _lowercase = 1   ,       _lowercase = None   ,       _lowercase = 0.0   ,       _lowercase = 50   ,       _lowercase = None   ,       _lowercase = "pil"   ,       _lowercase = True   ,       ):

												"""simple docstring"""



												if isinstance(self.unet.config.sample_size   ,       _lowercase				):
																		_lowerCAmelCase  						=			(
																		    batch_size,
																		    self.unet.config.in_channels,
																		    self.unet.config.sample_size,
																		    self.unet.config.sample_size,
																		)
												else:
																		_lowerCAmelCase  						=			(batch_size, self.unet.config.in_channels, *self.unet.config.sample_size)

												if isinstance(_lowercase   ,       _lowercase				) and len(_lowercase				) != batch_size:
																		raise ValueError(
																		    F'You have passed a list of generators of length {len(_lowercase				)}, but requested an effective batch'
																		    F' size of {batch_size}. Make sure the batch size matches the length of the generators.'				)

												_lowerCAmelCase  						=			randn_tensor(_lowercase   ,       generator=_lowercase   ,       device=self.device   ,       dtype=self.unet.dtype				)

												# set step values
												self.scheduler.set_timesteps(_lowercase				)

												for t in self.progress_bar(self.scheduler.timesteps				):
																		# 1. predict noise model_output
																		_lowerCAmelCase  						=			self.unet(_lowercase   ,       _lowercase				).sample

																		# 2. predict previous mean of image x_t-1 and add variance depending on eta
																		# eta corresponds to η in paper and should be between [0, 1]
																		# do x_t -> x_t-1
																		_lowerCAmelCase  						=			self.scheduler.step(
																		    _lowercase   ,       _lowercase   ,       _lowercase   ,       eta=_lowercase   ,       use_clipped_model_output=_lowercase   ,       generator=_lowercase				).prev_sample

												_lowerCAmelCase  						=			(image / 2 + 0.5).clamp(0   ,       1				)
												_lowerCAmelCase  						=			image.cpu().permute(0   ,       2   ,       3   ,       1				).numpy()
												if output_type == "pil":
																		_lowerCAmelCase  						=			self.numpy_to_pil(_lowercase				)

												if not return_dict:
																		return (image,)

												return ImagePipelineOutput(images=_lowercase				)
