




import unittest

import numpy as np
import torch

from diffusers import KarrasVePipeline, KarrasVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()



class       a					(       unittest.TestCase      ):

     '''simple docstring'''





     @property
     def   lowerCamelCase_       (     self       :      int    ):
         torch.manual_seed(0    )
         UpperCAmelCase_										=					UNetaDModel(
             block_out_channels=(32, 64) ,   layers_per_block=2 ,   sample_size=32 ,   in_channels=3 ,   out_channels=3 ,   down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''') ,   up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''') ,   )
         return model




     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         UpperCAmelCase_										=					self.dummy_uncond_unet
         UpperCAmelCase_										=					KarrasVeScheduler()

         UpperCAmelCase_										=					KarrasVePipeline(unet=__snake_case ,   scheduler=__snake_case    )
         pipe.to(__snake_case    )
         pipe.set_progress_bar_config(disable=__snake_case    )

         UpperCAmelCase_										=					torch.manual_seed(0    )
         UpperCAmelCase_										=					pipe(num_inference_steps=2 ,   generator=__snake_case ,   output_type='''numpy'''    ).images

         UpperCAmelCase_										=					torch.manual_seed(0    )
         UpperCAmelCase_										=					pipe(num_inference_steps=2 ,   generator=__snake_case ,   output_type='''numpy''' ,   return_dict=__snake_case    )[0]

         UpperCAmelCase_										=					image[0, -3:, -3:, -1]
         UpperCAmelCase_										=					image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 32, 32, 3)
         UpperCAmelCase_										=					np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]    )

         assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2
         assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1E-2



@slow
@require_torch
class       a					(       unittest.TestCase      ):

     '''simple docstring'''





     def   lowerCamelCase_       (     self       :      Any    ):
         UpperCAmelCase_										=					'''google/ncsnpp-celebahq-256'''
         UpperCAmelCase_										=					UNetaDModel.from_pretrained(__snake_case    )
         UpperCAmelCase_										=					KarrasVeScheduler()

         UpperCAmelCase_										=					KarrasVePipeline(unet=__snake_case ,   scheduler=__snake_case    )
         pipe.to(__snake_case    )
         pipe.set_progress_bar_config(disable=__snake_case    )

         UpperCAmelCase_										=					torch.manual_seed(0    )
         UpperCAmelCase_										=					pipe(num_inference_steps=20 ,   generator=__snake_case ,   output_type='''numpy'''    ).images

         UpperCAmelCase_										=					image[0, -3:, -3:, -1]
         assert image.shape == (1, 2_56, 2_56, 3)
         UpperCAmelCase_										=					np.array([0.578, 0.5_811, 0.5_924, 0.5_809, 0.587, 0.5_886, 0.5_861, 0.5_802, 0.586]    )

         assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2











def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Dict=2_8123				)  ->							str:
    UpperCAmelCase_										=					[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

    UpperCAmelCase_										=					set()
    UpperCAmelCase_										=					0

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

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

    return res


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





