



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
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 ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()





class  lowerCamelCase__	(    UpperCAmelCase_							,     unittest.TestCase):
     """simple docstring"""



     _A      =      KandinskyVaaControlnetImgaImgPipeline
     _A      =      ['image_embeds', 'negative_image_embeds', 'image', 'hint']
     _A      =      ['image_embeds', 'negative_image_embeds', 'image', 'hint']
     _A      =      [
         'generator',
         'height',
         'width',
         'strength',
         'guidance_scale',
         'num_inference_steps',
         'return_dict',
         'guidance_scale',
         'num_images_per_prompt',
         'output_type',
         'return_dict',
     ]
     _A      =      False







     @property
     def     _a   (self     ):






           '''simple docstring'''



           return 32







     @property
     def     _a   (self     ):






           '''simple docstring'''



           return 32







     @property
     def     _a   (self     ):






           '''simple docstring'''



           return self.time_input_dim







     @property
     def     _a   (self     ):






           '''simple docstring'''



           return self.time_input_dim * 4







     @property
     def     _a   (self     ):






           '''simple docstring'''



           return 1_00







     @property
     def     _a   (self     ):






           '''simple docstring'''



           torch.manual_seed(0     )

           lowerCamelCase             =		{
               "in_channels": 8,
               # Out channels is double in channels because predicts mean and variance
               "out_channels": 8,
               "addition_embed_type": "image_hint",
               "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
               "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
               "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
               "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
               "layers_per_block": 1,
               "encoder_hid_dim": self.text_embedder_hidden_size,
               "encoder_hid_dim_type": "image_proj",
               "cross_attention_dim": self.cross_attention_dim,
               "attention_head_dim": 4,
               "resnet_time_scale_shift": "scale_shift",
               "class_embed_type": None,
           }

           lowerCamelCase             =		UNetaDConditionModel(**__a     )
           return model







     @property
     def     _a   (self     ):






           '''simple docstring'''



           return {
               "block_out_channels": [32, 32, 64, 64],
               "down_block_types": [
                   "DownEncoderBlock2D",
                   "DownEncoderBlock2D",
                   "DownEncoderBlock2D",
                   "AttnDownEncoderBlock2D",
               ],
               "in_channels": 3,
               "latent_channels": 4,
               "layers_per_block": 1,
               "norm_num_groups": 8,
               "norm_type": "spatial",
               "num_vq_embeddings": 12,
               "out_channels": 3,
               "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
               "vq_embed_dim": 4,
           }







     @property
     def     _a   (self     ):






           '''simple docstring'''



           torch.manual_seed(0     )
           lowerCamelCase             =		VQModel(**self.dummy_movq_kwargs     )
           return model







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.dummy_unet
           lowerCamelCase             =		self.dummy_movq

           lowerCamelCase             =		{
               "num_train_timesteps": 10_00,
               "beta_schedule": "linear",
               "beta_start": 0.0_0085,
               "beta_end": 0.012,
               "clip_sample": False,
               "set_alpha_to_one": False,
               "steps_offset": 0,
               "prediction_type": "epsilon",
               "thresholding": False,
           }

           lowerCamelCase             =		DDIMScheduler(**__a     )

           lowerCamelCase             =		{
               "unet": unet,
               "scheduler": scheduler,
               "movq": movq,
           }

           return components







     def     _a   (self					,      __a					,      __a=0     ):






           '''simple docstring'''



           lowerCamelCase             =		floats_tensor((1, self.text_embedder_hidden_size)					,      rng=random.Random(__a     )     ).to(__a     )
           lowerCamelCase             =		floats_tensor((1, self.text_embedder_hidden_size)					,      rng=random.Random(seed + 1     )     ).to(
               __a     )
           # create init_image
           lowerCamelCase             =		floats_tensor((1, 3, 64, 64)					,      rng=random.Random(__a     )     ).to(__a     )
           lowerCamelCase             =		image.cpu().permute(0					,      2					,      3					,      1     )[0]
           lowerCamelCase             =		Image.fromarray(np.uinta(__a     )     ).convert("RGB"     ).resize((2_56, 2_56)     )
           # create hint
           lowerCamelCase             =		floats_tensor((1, 3, 64, 64)					,      rng=random.Random(__a     )     ).to(__a     )

           if str(__a     ).startswith("mps"     ):
                 lowerCamelCase             =		torch.manual_seed(__a     )
           else:
                 lowerCamelCase             =		torch.Generator(device=__a     ).manual_seed(__a     )
           lowerCamelCase             =		{
               "image": init_image,
               "image_embeds": image_embeds,
               "negative_image_embeds": negative_image_embeds,
               "hint": hint,
               "generator": generator,
               "height": 64,
               "width": 64,
               "num_inference_steps": 10,
               "guidance_scale": 7.0,
               "strength": 0.2,
               "output_type": "np",
           }
           return inputs







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		"cpu"

           lowerCamelCase             =		self.get_dummy_components()

           lowerCamelCase             =		self.pipeline_class(**__a     )
           lowerCamelCase             =		pipe.to(__a     )

           pipe.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		pipe(**self.get_dummy_inputs(__a     )     )
           lowerCamelCase             =		output.images

           lowerCamelCase             =		pipe(
               **self.get_dummy_inputs(__a     )					,      return_dict=__a					,      )[0]

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

           assert image.shape == (1, 64, 64, 3)

           lowerCamelCase             =		np.array(
               [0.5498_5034, 0.5550_9365, 0.5256_1504, 0.557_0494, 0.559_3818, 0.526_3979, 0.5028_5643, 0.506_9846, 0.5119_6736]     )
           assert (
               np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2
           ), F""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
           assert (
               np.abs(image_from_tuple_slice.flatten() - expected_slice     ).max() < 1E-2
           ), F""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""





@slow
@require_torch_gpu
class  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     def     _a   (self     ):






           '''simple docstring'''



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







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		load_numpy(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
               "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"     )

           lowerCamelCase             =		load_image(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"     )
           lowerCamelCase             =		init_image.resize((5_12, 5_12)     )

           lowerCamelCase             =		load_image(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
               "/kandinskyv22/hint_image_cat.png"     )
           lowerCamelCase             =		torch.from_numpy(np.array(__a     )     ).float() / 255.0
           lowerCamelCase             =		hint.permute(2					,      0					,      1     ).unsqueeze(0     )

           lowerCamelCase             =		"A robot, 4k photo"

           lowerCamelCase             =		KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
               "kandinsky-community/kandinsky-2-2-prior"					,      torch_dtype=torch.floataa     )
           pipe_prior.to(__a     )

           lowerCamelCase             =		KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
               "kandinsky-community/kandinsky-2-2-controlnet-depth"					,      torch_dtype=torch.floataa     )
           lowerCamelCase             =		pipeline.to(__a     )

           pipeline.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		torch.Generator(device="cpu"     ).manual_seed(0     )

           lowerCamelCase      ,				lowerCamelCase             =		pipe_prior(
               __a					,      image=__a					,      strength=0.85					,      generator=__a					,      negative_prompt=""					,      ).to_tuple()

           lowerCamelCase             =		pipeline(
               image=__a					,      image_embeds=__a					,      negative_image_embeds=__a					,      hint=__a					,      generator=__a					,      num_inference_steps=1_00					,      height=5_12					,      width=5_12					,      strength=0.5					,      output_type="np"					,      )

           lowerCamelCase             =		output.images[0]

           assert image.shape == (5_12, 5_12, 3)

           assert_mean_pixel_difference(__a					,      __a     )




def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      if n == 1 or not isinstance(UpperCAmelCase__ , UpperCAmelCase__			):
            return 0
      elif n == 2:
            return 1
      else:
            lowerCamelCase             =		[0, 1]
            for i in range(2 , n + 1			):
                  sequence.append(sequence[i - 1] + sequence[i - 2]			)

            return sequence[n]

def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		0
      lowerCamelCase             =		2

      while digits < n:
            index += 1
            lowerCamelCase             =		len(str(fibonacci(UpperCAmelCase__			)			)			)

      return index

def      __lowercase(						UpperCAmelCase__ = 1000			):


      """simple docstring"""



      return fibonacci_digits_index(UpperCAmelCase__			)


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