



'''simple docstring'''


import gc
import random
import unittest

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

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
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

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






def  UpperCAmelCase_       (		lowercase__       )     ->   Union[str, Any]:


     '''simple docstring'''







     a_       		=[tensor.shape for tensor in tensor_list]
     return all(shape == shapes[0] for shape in shapes[1:]       )







class 	UpperCAmelCase	(		__A					,	__A					,	__A					,	unittest.TestCase):


 '''simple docstring'''




 __magic_name__					: Optional[int]  =      StableDiffusionLatentUpscalePipeline
 __magic_name__					: Any  =      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
     "height",
     "width",
     "cross_attention_kwargs",
     "negative_prompt_embeds",
     "prompt_embeds",
 }
 __magic_name__					: List[str]  =      PipelineTesterMixin.required_optional_params - {"num_images_per_prompt"}
 __magic_name__					: Union[str, Any]  =      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 __magic_name__					: int  =      frozenset(
     [])  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
 __magic_name__					: Dict  =      frozenset([])

 __magic_name__					: str  =      True




 @property
 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







      a_       		=1
      a_       		=4
      a_       		=(1_6, 1_6)

      a_       		=floats_tensor((batch_size, num_channels) + sizes							,  rng=random.Random(0)).to(lowerCAmelCase_)
      return image




 def       lowercase_  (   self) ->      List[str]:



      """simple docstring"""







      torch.manual_seed(0)
      a_       		=UNetaDConditionModel(
          act_fn="gelu"							,  attention_head_dim=8							,  norm_num_groups=lowerCAmelCase_							,  block_out_channels=[3_2, 3_2, 6_4, 6_4]							,  time_cond_proj_dim=1_6_0							,  conv_in_kernel=1							,  conv_out_kernel=1							,  cross_attention_dim=3_2							,  down_block_types=(
              "KDownBlock2D",
              "KCrossAttnDownBlock2D",
              "KCrossAttnDownBlock2D",
              "KCrossAttnDownBlock2D",
          )							,  in_channels=8							,  mid_block_type=lowerCAmelCase_							,  only_cross_attention=lowerCAmelCase_							,  out_channels=5							,  resnet_time_scale_shift="scale_shift"							,  time_embedding_type="fourier"							,  timestep_post_act="gelu"							,  up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")							,  )
      a_       		=AutoencoderKL(
          block_out_channels=[3_2, 3_2, 6_4, 6_4]							,  in_channels=3							,  out_channels=3							,  down_block_types=[
              "DownEncoderBlock2D",
              "DownEncoderBlock2D",
              "DownEncoderBlock2D",
              "DownEncoderBlock2D",
          ]							,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]							,  latent_channels=4							,  )
      a_       		=EulerDiscreteScheduler(prediction_type="sample")
      a_       		=CLIPTextConfig(
          bos_token_id=0							,  eos_token_id=2							,  hidden_size=3_2							,  intermediate_size=3_7							,  layer_norm_eps=1e-05							,  num_attention_heads=4							,  num_hidden_layers=5							,  pad_token_id=1							,  vocab_size=1_0_0_0							,  hidden_act="quick_gelu"							,  projection_dim=5_1_2							,  )
      a_       		=CLIPTextModel(lowerCAmelCase_)
      a_       		=CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

      a_       		={
          '''unet''': model.eval(),
          '''vae''': vae.eval(),
          '''scheduler''': scheduler,
          '''text_encoder''': text_encoder,
          '''tokenizer''': tokenizer,
      }

      return components




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_=0) ->      List[str]:



      """simple docstring"""







      if str(lowerCAmelCase_).startswith("mps"):
           a_       		=torch.manual_seed(lowerCAmelCase_)
      else:
           a_       		=torch.Generator(device=lowerCAmelCase_).manual_seed(lowerCAmelCase_)
      a_       		={
          '''prompt''': '''A painting of a squirrel eating a burger''',
          '''image''': self.dummy_image.cpu(),
          '''generator''': generator,
          '''num_inference_steps''': 2,
          '''output_type''': '''numpy''',
      }
      return inputs




 def       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      a_       		='''cpu'''

      a_       		=self.get_dummy_components()
      a_       		=self.pipeline_class(**lowerCAmelCase_)
      pipe.to(lowerCAmelCase_)
      pipe.set_progress_bar_config(disable=lowerCAmelCase_)

      a_       		=self.get_dummy_inputs(lowerCAmelCase_)
      a_       		=pipe(**lowerCAmelCase_).images
      a_       		=image[0, -3:, -3:, -1]

      self.assertEqual(image.shape							,  (1, 2_5_6, 2_5_6, 3))
      a_       		=np.array(
          [0.4_7_2_2_2_4_1_2, 0.4_1_9_2_1_6_3_3, 0.4_4_7_1_7_4_3_4, 0.4_6_8_7_4_1_9_2, 0.4_2_5_8_8_2_5_8, 0.4_6_1_5_0_7_2_6, 0.4_6_7_7_5_3_4, 0.4_5_5_8_3_8_3_2, 0.4_8_5_7_9_0_5_5])
      a_       		=np.abs(image_slice.flatten() - expected_slice).max()
      self.assertLessEqual(lowerCAmelCase_							,  1e-3)




 def       lowercase_  (   self) ->      List[str]:



      """simple docstring"""







      super().test_attention_slicing_forward_pass(expected_max_diff=7e-3)




 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







      super().test_cpu_offload_forward_pass(expected_max_diff=3e-3)




 def       lowercase_  (   self) ->      int:



      """simple docstring"""







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




 def       lowercase_  (   self) ->      List[str]:



      """simple docstring"""







      super().test_inference_batch_single_identical(expected_max_diff=7e-3)




 def       lowercase_  (   self) ->      int:



      """simple docstring"""







      super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3)




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







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




 def       lowercase_  (   self) ->      Optional[int]:



      """simple docstring"""







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




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







      a_       		=[
          '''DDIMScheduler''',
          '''DDPMScheduler''',
          '''PNDMScheduler''',
          '''HeunDiscreteScheduler''',
          '''EulerAncestralDiscreteScheduler''',
          '''KDPM2DiscreteScheduler''',
          '''KDPM2AncestralDiscreteScheduler''',
          '''DPMSolverSDEScheduler''',
      ]
      a_       		=self.get_dummy_components()
      a_       		=self.pipeline_class(**lowerCAmelCase_)

      # make sure that PNDM does not need warm-up
      pipe.scheduler.register_to_config(skip_prk_steps=lowerCAmelCase_)

      pipe.to(lowerCAmelCase_)
      pipe.set_progress_bar_config(disable=lowerCAmelCase_)
      a_       		=self.get_dummy_inputs(lowerCAmelCase_)
      a_       		=2

      a_       		=[]
      for scheduler_enum in KarrasDiffusionSchedulers:
           if scheduler_enum.name in skip_schedulers:
                # no sigma schedulers are not supported
                # no schedulers
                continue

           a_       		=getattr(lowerCAmelCase_							,  scheduler_enum.name)
           a_       		=scheduler_cls.from_config(pipe.scheduler.config)
           a_       		=pipe(**lowerCAmelCase_)[0]
           outputs.append(lowerCAmelCase_)

      assert check_same_shape(lowerCAmelCase_)







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


 '''simple docstring'''




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







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




 def       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      a_       		=torch.manual_seed(3_3)

      a_       		=StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"							,  torch_dtype=torch.floataa)
      pipe.to("cuda")

      a_       		=StableDiffusionLatentUpscalePipeline.from_pretrained(
          "stabilityai/sd-x2-latent-upscaler"							,  torch_dtype=torch.floataa)
      upscaler.to("cuda")

      a_       		='''a photo of an astronaut high resolution, unreal engine, ultra realistic'''

      a_       		=pipe(lowerCAmelCase_							,  generator=lowerCAmelCase_							,  output_type="latent").images

      a_       		=upscaler(
          prompt=lowerCAmelCase_							,  image=lowerCAmelCase_							,  num_inference_steps=2_0							,  guidance_scale=0							,  generator=lowerCAmelCase_							,  output_type="np"							,  ).images[0]

      a_       		=load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy")
      assert np.abs((expected_image - image).mean()) < 5e-2




 def       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      a_       		=torch.manual_seed(3_3)

      a_       		=StableDiffusionLatentUpscalePipeline.from_pretrained(
          "stabilityai/sd-x2-latent-upscaler"							,  torch_dtype=torch.floataa)
      upscaler.to("cuda")

      a_       		='''the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'''

      a_       		=load_image(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png")

      a_       		=upscaler(
          prompt=lowerCAmelCase_							,  image=lowerCAmelCase_							,  num_inference_steps=2_0							,  guidance_scale=0							,  generator=lowerCAmelCase_							,  output_type="np"							,  ).images[0]

      a_       		=load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy")
      assert np.abs((expected_image - image).max()) < 5e-2







'''simple docstring'''


from collections.abc import Generator






def  UpperCAmelCase_       (		):


     '''simple docstring'''







     a_		,						a_       		=0, 1
     while True:
          a_		,						a_       		=b, a + b
          yield b






def  UpperCAmelCase_       (		lowercase__ = 1_0_0_0       ):


     '''simple docstring'''







     a_       		=1
     a_       		=fibonacci_generator()
     while len(str(next(lowercase__       )       )       ) < n:
          answer += 1
     return answer + 1


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


