






'''simple docstring'''

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()
class _lowerCamelCase	(						unittest.TestCase							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						Optional[Any]      )  ->			int:
			# clean up the VRAM after each test
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()







		@property
		def        __lowerCAmelCase		( self		:						str      )  ->			Tuple:
			__magic_name__	:   Union[str, Any]					     =					1
			__magic_name__	:   str					     =					3
			__magic_name__	:   Any					     =					(32, 32)

			__magic_name__	:   Optional[Any]					     =					floats_tensor((batch_size, num_channels) + sizes  ,					rng=random.Random(0      )      ).to(_A      )
			return image







		@property
		def        __lowerCAmelCase		( self		:						List[str]      )  ->			Dict:
			torch.manual_seed(0      )
			__magic_name__	:   str					     =					UNetaDConditionModel(
			    block_out_channels=(32, 32, 64)  ,					layers_per_block=2  ,					sample_size=32  ,					in_channels=7  ,					out_channels=4  ,					down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D')  ,					up_block_types=('CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'UpBlock2D')  ,					cross_attention_dim=32  ,					attention_head_dim=8  ,					use_linear_projection=_A  ,					only_cross_attention=(True, True, False)  ,					num_class_embeds=100  ,					)
			return model







		@property
		def        __lowerCAmelCase		( self		:						List[Any]      )  ->			str:
			torch.manual_seed(0      )
			__magic_name__	:   List[Any]					     =					AutoencoderKL(
			    block_out_channels=[32, 32, 64]  ,					in_channels=3  ,					out_channels=3  ,					down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D']  ,					up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']  ,					latent_channels=4  ,					)
			return model







		@property
		def        __lowerCAmelCase		( self		:						Dict      )  ->			Dict:
			torch.manual_seed(0      )
			__magic_name__	:   int					     =					CLIPTextConfig(
			    bos_token_id=0  ,					eos_token_id=2  ,					hidden_size=32  ,					intermediate_size=37  ,					layer_norm_eps=1E-05  ,					num_attention_heads=4  ,					num_hidden_layers=5  ,					pad_token_id=1  ,					vocab_size=1000  ,					hidden_act='gelu'  ,					projection_dim=512  ,					)
			return CLIPTextModel(_A      )







		def        __lowerCAmelCase		( self		:						Any      )  ->			Dict:
			__magic_name__	:   Optional[Any]					     =					'cpu'  # ensure determinism for the device-dependent torch.Generator
			__magic_name__	:   Any					     =					self.dummy_cond_unet_upscale
			__magic_name__	:   Optional[int]					     =					DDPMScheduler()
			__magic_name__	:   Dict					     =					DDIMScheduler(prediction_type='v_prediction'      )
			__magic_name__	:   Dict					     =					self.dummy_vae
			__magic_name__	:   Union[str, Any]					     =					self.dummy_text_encoder
			__magic_name__	:   List[Any]					     =					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

			__magic_name__	:   int					     =					self.dummy_image.cpu().permute(0  ,					2  ,					3  ,					1      )[0]
			__magic_name__	:   str					     =					Image.fromarray(np.uinta(_A      )      ).convert('RGB'      ).resize((64, 64)      )

			# make sure here that pndm scheduler skips prk
			__magic_name__	:   int					     =					StableDiffusionUpscalePipeline(
			    unet=_A  ,					low_res_scheduler=_A  ,					scheduler=_A  ,					vae=_A  ,					text_encoder=_A  ,					tokenizer=_A  ,					max_noise_level=350  ,					)
			__magic_name__	:   Optional[int]					     =					sd_pipe.to(_A      )
			sd_pipe.set_progress_bar_config(disable=_A      )

			__magic_name__	:   Any					     =					'A painting of a squirrel eating a burger'
			__magic_name__	:   Tuple					     =					torch.Generator(device=_A      ).manual_seed(0      )
			__magic_name__	:   List[Any]					     =					sd_pipe(
			    [prompt]  ,					image=_A  ,					generator=_A  ,					guidance_scale=6.0  ,					noise_level=20  ,					num_inference_steps=2  ,					output_type='np'  ,					)

			__magic_name__	:   List[Any]					     =					output.images

			__magic_name__	:   Any					     =					torch.Generator(device=_A      ).manual_seed(0      )
			__magic_name__	:   List[Any]					     =					sd_pipe(
			    [prompt]  ,					image=_A  ,					generator=_A  ,					guidance_scale=6.0  ,					noise_level=20  ,					num_inference_steps=2  ,					output_type='np'  ,					return_dict=_A  ,					)[0]

			__magic_name__	:   Dict					     =					image[0, -3:, -3:, -1]
			__magic_name__	:   Optional[Any]					     =					image_from_tuple[0, -3:, -3:, -1]

			__magic_name__	:   Union[str, Any]					     =					low_res_image.size[0] * 4
			assert image.shape == (1, expected_height_width, expected_height_width, 3)
			__magic_name__	:   int					     =					np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]      )

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







		def        __lowerCAmelCase		( self		:						List[Any]      )  ->			Union[str, Any]:
			__magic_name__	:   Union[str, Any]					     =					'cpu'  # ensure determinism for the device-dependent torch.Generator
			__magic_name__	:   List[Any]					     =					self.dummy_cond_unet_upscale
			__magic_name__	:   List[Any]					     =					DDPMScheduler()
			__magic_name__	:   str					     =					DDIMScheduler(prediction_type='v_prediction'      )
			__magic_name__	:   Tuple					     =					self.dummy_vae
			__magic_name__	:   Optional[Any]					     =					self.dummy_text_encoder
			__magic_name__	:   Dict					     =					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

			__magic_name__	:   Optional[int]					     =					self.dummy_image.cpu().permute(0  ,					2  ,					3  ,					1      )[0]
			__magic_name__	:   List[Any]					     =					Image.fromarray(np.uinta(_A      )      ).convert('RGB'      ).resize((64, 64)      )

			# make sure here that pndm scheduler skips prk
			__magic_name__	:   Dict					     =					StableDiffusionUpscalePipeline(
			    unet=_A  ,					low_res_scheduler=_A  ,					scheduler=_A  ,					vae=_A  ,					text_encoder=_A  ,					tokenizer=_A  ,					max_noise_level=350  ,					)
			__magic_name__	:   Optional[Any]					     =					sd_pipe.to(_A      )
			sd_pipe.set_progress_bar_config(disable=_A      )

			__magic_name__	:   Union[str, Any]					     =					'A painting of a squirrel eating a burger'
			__magic_name__	:   str					     =					sd_pipe(
			    2 * [prompt]  ,					image=2 * [low_res_image]  ,					guidance_scale=6.0  ,					noise_level=20  ,					num_inference_steps=2  ,					output_type='np'  ,					)
			__magic_name__	:   List[str]					     =					output.images
			assert image.shape[0] == 2

			__magic_name__	:   Union[str, Any]					     =					torch.Generator(device=_A      ).manual_seed(0      )
			__magic_name__	:   List[str]					     =					sd_pipe(
			    [prompt]  ,					image=_A  ,					generator=_A  ,					num_images_per_prompt=2  ,					guidance_scale=6.0  ,					noise_level=20  ,					num_inference_steps=2  ,					output_type='np'  ,					)
			__magic_name__	:   Tuple					     =					output.images
			assert image.shape[0] == 2







		@unittest.skipIf(torch_device != 'cuda'  ,					'This test requires a GPU'      )
		def        __lowerCAmelCase		( self		:						List[str]      )  ->			Any:
			__magic_name__	:   Optional[int]					     =					self.dummy_cond_unet_upscale
			__magic_name__	:   str					     =					DDPMScheduler()
			__magic_name__	:   Union[str, Any]					     =					DDIMScheduler(prediction_type='v_prediction'      )
			__magic_name__	:   List[Any]					     =					self.dummy_vae
			__magic_name__	:   Optional[int]					     =					self.dummy_text_encoder
			__magic_name__	:   str					     =					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

			__magic_name__	:   Tuple					     =					self.dummy_image.cpu().permute(0  ,					2  ,					3  ,					1      )[0]
			__magic_name__	:   str					     =					Image.fromarray(np.uinta(_A      )      ).convert('RGB'      ).resize((64, 64)      )

			# put models in fp16, except vae as it overflows in fp16
			__magic_name__	:   Tuple					     =					unet.half()
			__magic_name__	:   Any					     =					text_encoder.half()

			# make sure here that pndm scheduler skips prk
			__magic_name__	:   Tuple					     =					StableDiffusionUpscalePipeline(
			    unet=_A  ,					low_res_scheduler=_A  ,					scheduler=_A  ,					vae=_A  ,					text_encoder=_A  ,					tokenizer=_A  ,					max_noise_level=350  ,					)
			__magic_name__	:   Any					     =					sd_pipe.to(_A      )
			sd_pipe.set_progress_bar_config(disable=_A      )

			__magic_name__	:   int					     =					'A painting of a squirrel eating a burger'
			__magic_name__	:   Optional[Any]					     =					torch.manual_seed(0      )
			__magic_name__	:   List[str]					     =					sd_pipe(
			    [prompt]  ,					image=_A  ,					generator=_A  ,					num_inference_steps=2  ,					output_type='np'  ,					).images

			__magic_name__	:   Tuple					     =					low_res_image.size[0] * 4
			assert image.shape == (1, expected_height_width, expected_height_width, 3)







@slow
@require_torch_gpu
class _lowerCamelCase	(						unittest.TestCase							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						str      )  ->			Union[str, Any]:
			# clean up the VRAM after each test
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()







		def        __lowerCAmelCase		( self		:						int      )  ->			Dict:
			__magic_name__	:   Dict					     =					load_image(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/sd2-upscale/low_res_cat.png'      )
			__magic_name__	:   Any					     =					load_numpy(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
			    '/upsampled_cat.npy'      )

			__magic_name__	:   Any					     =					'stabilityai/stable-diffusion-x4-upscaler'
			__magic_name__	:   Dict					     =					StableDiffusionUpscalePipeline.from_pretrained(_A      )
			pipe.to(_A      )
			pipe.set_progress_bar_config(disable=_A      )
			pipe.enable_attention_slicing()

			__magic_name__	:   Optional[int]					     =					'a cat sitting on a park bench'

			__magic_name__	:   List[Any]					     =					torch.manual_seed(0      )
			__magic_name__	:   List[Any]					     =					pipe(
			    prompt=_A  ,					image=_A  ,					generator=_A  ,					output_type='np'  ,					)
			__magic_name__	:   List[Any]					     =					output.images[0]

			assert image.shape == (512, 512, 3)
			assert np.abs(expected_image - image      ).max() < 1E-3







		def        __lowerCAmelCase		( self		:						Any      )  ->			Union[str, Any]:
			__magic_name__	:   Optional[int]					     =					load_image(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/sd2-upscale/low_res_cat.png'      )
			__magic_name__	:   Union[str, Any]					     =					load_numpy(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
			    '/upsampled_cat_fp16.npy'      )

			__magic_name__	:   Optional[Any]					     =					'stabilityai/stable-diffusion-x4-upscaler'
			__magic_name__	:   Optional[int]					     =					StableDiffusionUpscalePipeline.from_pretrained(
			    _A  ,					torch_dtype=torch.floataa  ,					)
			pipe.to(_A      )
			pipe.set_progress_bar_config(disable=_A      )
			pipe.enable_attention_slicing()

			__magic_name__	:   str					     =					'a cat sitting on a park bench'

			__magic_name__	:   Tuple					     =					torch.manual_seed(0      )
			__magic_name__	:   Any					     =					pipe(
			    prompt=_A  ,					image=_A  ,					generator=_A  ,					output_type='np'  ,					)
			__magic_name__	:   Union[str, Any]					     =					output.images[0]

			assert image.shape == (512, 512, 3)
			assert np.abs(expected_image - image      ).max() < 5E-1







		def        __lowerCAmelCase		( self		:						List[Any]      )  ->			List[Any]:
			torch.cuda.empty_cache()
			torch.cuda.reset_max_memory_allocated()
			torch.cuda.reset_peak_memory_stats()

			__magic_name__	:   Any					     =					load_image(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/sd2-upscale/low_res_cat.png'      )

			__magic_name__	:   str					     =					'stabilityai/stable-diffusion-x4-upscaler'
			__magic_name__	:   int					     =					StableDiffusionUpscalePipeline.from_pretrained(
			    _A  ,					torch_dtype=torch.floataa  ,					)
			pipe.to(_A      )
			pipe.set_progress_bar_config(disable=_A      )
			pipe.enable_attention_slicing(1      )
			pipe.enable_sequential_cpu_offload()

			__magic_name__	:   List[Any]					     =					'a cat sitting on a park bench'

			__magic_name__	:   Dict					     =					torch.manual_seed(0      )
			__magic_name__	:   Dict					     =					pipe(
			    prompt=_A  ,					image=_A  ,					generator=_A  ,					num_inference_steps=5  ,					output_type='np'  ,					)

			__magic_name__	:   Dict					     =					torch.cuda.max_memory_allocated()
			# make sure that less than 2.9 GB is allocated
			assert mem_bytes < 2.9 * 10**9



'''simple docstring'''

def lowerCamelCase      (      lowerCAmelCase    :     int		):





	"""simple docstring"""







	__magic_name__	:   Optional[int]					     =					1
	for i in range(1		,		num + 1		):
		fact *= i
	return fact





def lowerCamelCase      (      lowerCAmelCase    :     int		):





	"""simple docstring"""







	__magic_name__	:   List[str]					     =					0
	while number > 0:
		__magic_name__	:   str					     =					number % 10
		sum_of_digits += last_digit
		__magic_name__	:   Optional[int]					     =					number // 10  # Removing the last_digit from the given number
	return sum_of_digits





def lowerCamelCase      (      lowerCAmelCase    :     int = 100		):





	"""simple docstring"""







	__magic_name__	:   int					     =					factorial(lowerCAmelCase		)
	__magic_name__	:   Any					     =					split_and_add(lowerCAmelCase		)
	return result


if __name__ == "__main__":
							print(solution(int(input('''Enter the Number: ''').strip())))