






"""simple docstring"""



import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


A_    =							False






@skip_mps
class 							__SCREAMING_SNAKE_CASE						(				UpperCamelCase       ,		UpperCamelCase       ,		UpperCamelCase       ,		unittest.TestCase		):
		snake_case_     =							StableDiffusionAttendAndExcitePipeline
		snake_case_     =							False
		snake_case_     =							TEXT_TO_IMAGE_PARAMS
		snake_case_     =							TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}		)
		snake_case_     =							TEXT_TO_IMAGE_IMAGE_PARAMS
		snake_case_     =							TEXT_TO_IMAGE_IMAGE_PARAMS


		@classmethod
		def 						_UpperCamelCase       (			cls      :						Optional[Any]							):
								'''simple docstring'''





								super().setUpClass()
								torch.use_deterministic_algorithms(snake_case							)


		@classmethod
		def 						_UpperCamelCase       (			cls      :						List[str]							):
								'''simple docstring'''





								super().tearDownClass()
								torch.use_deterministic_algorithms(snake_case							)


		def 						_UpperCamelCase       (			self      :						Tuple							):
								'''simple docstring'''





								torch.manual_seed(0							)
								A__						:  Optional[int]		  =  UNetaDConditionModel(
								    block_out_channels=(32, 64)			,    layers_per_block=1			,    sample_size=32			,    in_channels=4			,    out_channels=4			,    down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")			,    up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")			,    cross_attention_dim=32			,    attention_head_dim=(2, 4)			,    use_linear_projection=snake_case			,    )
								A__						:  List[Any]		  =  DDIMScheduler(
								    beta_start=0.00085			,    beta_end=0.012			,    beta_schedule="""scaled_linear"""			,    clip_sample=snake_case			,    set_alpha_to_one=snake_case			,    )
								torch.manual_seed(0							)
								A__						:  List[Any]		  =  AutoencoderKL(
								    block_out_channels=[32, 64]			,    in_channels=3			,    out_channels=3			,    down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]			,    up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]			,    latent_channels=4			,    sample_size=128			,    )
								torch.manual_seed(0							)
								A__						:  List[str]		  =  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			,    )
								A__						:  Any		  =  CLIPTextModel(snake_case							)
								A__						:  Optional[int]		  =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

								A__						:  Optional[int]		  =  {
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """safety_checker""": None,
								    """feature_extractor""": None,
								}

								return components


		def 						_UpperCamelCase       (			self      :						Tuple			,    snake_case      :						Any			,    snake_case      :						List[str]=0							):
								'''simple docstring'''





								if str(snake_case							).startswith("""mps"""							):
														A__						:  int		  =  torch.manual_seed(snake_case							)
								else:
														A__						:  int		  =  torch.Generator(device=snake_case							).manual_seed(snake_case							)
								A__						:  Optional[int]		  =  {
								    """prompt""": """a cat and a frog""",
								    """token_indices""": [2, 5],
								    """generator""": generator,
								    """num_inference_steps""": 1,
								    """guidance_scale""": 6.0,
								    """output_type""": """numpy""",
								    """max_iter_to_alter""": 2,
								    """thresholds""": {0: 0.7},
								}
								return inputs


		def 						_UpperCamelCase       (			self      :						str							):
								'''simple docstring'''





								A__						:  List[Any]		  =  """cpu"""

								A__						:  Dict		  =  self.get_dummy_components()
								A__						:  Dict		  =  self.pipeline_class(**snake_case							)
								pipe.to(snake_case							)
								pipe.set_progress_bar_config(disable=snake_case							)

								A__						:  int		  =  self.get_dummy_inputs(snake_case							)
								A__						:  Optional[Any]		  =  pipe(**snake_case							).images
								A__						:  List[str]		  =  image[0, -3:, -3:, -1]

								self.assertEqual(image.shape			,    (1, 64, 64, 3)							)
								A__						:  List[str]		  =  np.array(
								    [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]							)
								A__						:  Optional[int]		  =  np.abs(image_slice.flatten() - expected_slice							).max()
								self.assertLessEqual(snake_case			,    1e-3							)


		def 						_UpperCamelCase       (			self      :						List[str]							):
								'''simple docstring'''





								super().test_cpu_offload_forward_pass(expected_max_diff=5e-4							)


		def 						_UpperCamelCase       (			self      :						Dict							):
								'''simple docstring'''





								self._test_inference_batch_consistent(batch_sizes=[1, 2]							)


		def 						_UpperCamelCase       (			self      :						Tuple							):
								'''simple docstring'''





								self._test_inference_batch_single_identical(batch_size=2			,    expected_max_diff=7e-4							)


		def 						_UpperCamelCase       (			self      :						List[str]							):
								'''simple docstring'''





								super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3							)


		def 						_UpperCamelCase       (			self      :						int							):
								'''simple docstring'''





								super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4							)


		def 						_UpperCamelCase       (			self      :						Optional[Any]							):
								'''simple docstring'''





								super().test_save_load_local(expected_max_difference=5e-4							)


		def 						_UpperCamelCase       (			self      :						Dict							):
								'''simple docstring'''





								super().test_save_load_optional_components(expected_max_difference=4e-4							)






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


		@classmethod
		def 						_UpperCamelCase       (			cls      :						Dict							):
								'''simple docstring'''





								super().setUpClass()
								torch.use_deterministic_algorithms(snake_case							)


		@classmethod
		def 						_UpperCamelCase       (			cls      :						Tuple							):
								'''simple docstring'''





								super().tearDownClass()
								torch.use_deterministic_algorithms(snake_case							)


		def 						_UpperCamelCase       (			self      :						int							):
								'''simple docstring'''





								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()


		def 						_UpperCamelCase       (			self      :						Tuple							):
								'''simple docstring'''





								A__						:  Any		  =  torch.manual_seed(51							)

								A__						:  Tuple		  =  StableDiffusionAttendAndExcitePipeline.from_pretrained(
								    """CompVis/stable-diffusion-v1-4"""			,    safety_checker=snake_case			,    torch_dtype=torch.floataa							)
								pipe.to("""cuda"""							)

								A__						:  Any		  =  """a painting of an elephant with glasses"""
								A__						:  int		  =  [5, 7]

								A__						:  Dict		  =  pipe(
								    prompt=snake_case			,    token_indices=snake_case			,    guidance_scale=7.5			,    generator=snake_case			,    num_inference_steps=5			,    max_iter_to_alter=5			,    output_type="""numpy"""			,    ).images[0]

								A__						:  Any		  =  load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy"""							)
								assert np.abs((expected_image - image).max()							) < 5e-1














"""simple docstring"""



def      _lowerCAmelCase		(							UpperCAmelCase__       :					int = 1_0_0_0      )		->int:
						A__						:  Optional[int]		  =  2**power
						A__						:  Dict		  =  0
						while n:
												A__  ,  A__						:  Tuple		  =  r + n % 1_0, n // 1_0
						return r


if __name__ == "__main__":
						print(solution(int(str(input()).strip())))






