




'''simple docstring'''
import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device
def 				snake_case_  (   a__		:	nn.Module			):



    """simple docstring"""




    __lowercase							=						{}
    for name in unet.attn_processors.keys():
        __lowercase							=						None if name.endswith("""attn1.processor"""			) else unet.config.cross_attention_dim
        if name.startswith("""mid_block"""			):
            __lowercase							=						unet.config.block_out_channels[-1]
        elif name.startswith("""up_blocks"""			):
            __lowercase							=						int(name[len("""up_blocks."""			)]			)
            __lowercase							=						list(reversed(unet.config.block_out_channels			)			)[block_id]
        elif name.startswith("""down_blocks"""			):
            __lowercase							=						int(name[len("""down_blocks."""			)]			)
            __lowercase							=						unet.config.block_out_channels[block_id]
        __lowercase							=						(
            LoRAAttnProcessor2_0 if hasattr(a__    ,"""scaled_dot_product_attention"""			) else LoRAAttnProcessor
        )
        __lowercase							=						lora_attn_processor_class(
            hidden_size=a__    ,cross_attention_dim=a__			)
    __lowercase							=						AttnProcsLayers(a__			)
    return lora_attn_procs, unet_lora_layers
def 				snake_case_  (   a__		:	nn.Module			):



    """simple docstring"""




    __lowercase							=						{}
    __lowercase							=						(
        LoRAAttnProcessor2_0 if hasattr(a__    ,"""scaled_dot_product_attention"""			) else LoRAAttnProcessor
    )
    for name, module in text_encoder.named_modules():
        if name.endswith(a__			):
            __lowercase							=						lora_attn_processor_class(
                hidden_size=module.out_proj.out_features    ,cross_attention_dim=a__			)
    return text_lora_attn_procs
def 				snake_case_  (   a__		:	nn.Module			):



    """simple docstring"""




    __lowercase							=						create_text_encoder_lora_attn_procs(a__			)
    __lowercase							=						AttnProcsLayers(a__			)
    return text_encoder_lora_layers
def 				snake_case_  (   a__		:	Optional[int]    ,a__		:	List[str]=False			):



    """simple docstring"""




    for _, attn_proc in text_lora_attn_procs.items():
        # set up.weights
        for layer_name, layer_module in attn_proc.named_modules():
            if layer_name.endswith("""_lora"""			):
                __lowercase							=						(
                    torch.randn_like(layer_module.up.weight			)
                    if randn_weight
                    else torch.zeros_like(layer_module.up.weight			)
                )
                __lowercase							=						torch.nn.Parameter(a__			)






class        SCREAMING_SNAKE_CASE(				unittest.TestCase     ):

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

           """simple docstring"""



           torch.manual_seed(0     )
           __lowercase							=						UNetaDConditionModel(
               block_out_channels=(32, 64)					,		layers_per_block=2					,		sample_size=32					,		in_channels=4					,		out_channels=4					,		down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")					,		up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")					,		cross_attention_dim=32					,		)
           __lowercase							=						DDIMScheduler(
               beta_start=0.0_00_85					,		beta_end=0.0_12					,		beta_schedule="""scaled_linear"""					,		clip_sample=lowerCamelCase__					,		set_alpha_to_one=lowerCamelCase__					,		steps_offset=1					,		)
           torch.manual_seed(0     )
           __lowercase							=						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					,		)
           __lowercase							=						CLIPTextConfig(
               bos_token_id=0					,		eos_token_id=2					,		hidden_size=32					,		intermediate_size=37					,		layer_norm_eps=1E-0_5					,		num_attention_heads=4					,		num_hidden_layers=5					,		pad_token_id=1					,		vocab_size=1000					,		)
           __lowercase							=						CLIPTextModel(lowerCamelCase__     )
           __lowercase							=						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

           __lowercase				,__lowercase							=						create_unet_lora_layers(lowerCamelCase__     )
           __lowercase							=						create_text_encoder_lora_layers(lowerCamelCase__     )

           __lowercase							=						{
               """unet""": unet,
               """scheduler""": scheduler,
               """vae""": vae,
               """text_encoder""": text_encoder,
               """tokenizer""": tokenizer,
               """safety_checker""": None,
               """feature_extractor""": None,
           }
           __lowercase							=						{
               """unet_lora_layers""": unet_lora_layers,
               """text_encoder_lora_layers""": text_encoder_lora_layers,
               """unet_lora_attn_procs""": unet_lora_attn_procs,
           }
           return pipeline_components, lora_components

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

           """simple docstring"""



           __lowercase							=						1
           __lowercase							=						10
           __lowercase							=						4
           __lowercase							=						(32, 32)

           __lowercase							=						torch.manual_seed(0     )
           __lowercase							=						floats_tensor((batch_size, num_channels) + sizes     )
           __lowercase							=						torch.randint(1					,		lowerCamelCase__					,		size=(batch_size, sequence_length)					,		generator=lowerCamelCase__     )

           __lowercase							=						{
               """prompt""": """A painting of a squirrel eating a burger""",
               """generator""": generator,
               """num_inference_steps""": 2,
               """guidance_scale""": 6.0,
               """output_type""": """numpy""",
           }

           return noise, input_ids, pipeline_inputs

           # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb

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

           """simple docstring"""



           __lowercase							=						77

           __lowercase							=						torch.randint(2					,		56					,		size=(1, max_seq_length)					,		generator=torch.manual_seed(0     )     )

           __lowercase							=						{}
           __lowercase							=						inputs
           return prepared_inputs

       def     snake_case__			(    self					,		lowerCamelCase__     )    ->					int:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           LoraLoaderMixin.save_lora_weights(
               save_directory=lowerCamelCase__					,		unet_lora_layers=lora_components["""unet_lora_layers"""]					,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]					,		)
           self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,		"""pytorch_lora_weights.bin"""     )     )     )

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

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )
           __lowercase							=						sd_pipe.to(lowerCamelCase__     )
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__     )

           __lowercase				,__lowercase				,__lowercase							=						self.get_dummy_inputs()

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						original_images[0, -3:, -3:, -1]

           with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=lowerCamelCase__					,		unet_lora_layers=lora_components["""unet_lora_layers"""]					,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]					,		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,		"""pytorch_lora_weights.bin"""     )     )     )
               sd_pipe.load_lora_weights(lowerCamelCase__     )

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						lora_images[0, -3:, -3:, -1]

           # Outputs shouldn't match.
           self.assertFalse(torch.allclose(torch.from_numpy(lowerCamelCase__     )					,		torch.from_numpy(lowerCamelCase__     )     )     )

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

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )
           __lowercase							=						sd_pipe.to(lowerCamelCase__     )
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__     )

           __lowercase				,__lowercase				,__lowercase							=						self.get_dummy_inputs()

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						original_images[0, -3:, -3:, -1]

           with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=lowerCamelCase__					,		unet_lora_layers=lora_components["""unet_lora_layers"""]					,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]					,		safe_serialization=lowerCamelCase__					,		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,		"""pytorch_lora_weights.safetensors"""     )     )     )
               sd_pipe.load_lora_weights(lowerCamelCase__     )

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						lora_images[0, -3:, -3:, -1]

           # Outputs shouldn't match.
           self.assertFalse(torch.allclose(torch.from_numpy(lowerCamelCase__     )					,		torch.from_numpy(lowerCamelCase__     )     )     )

       def     snake_case__			(    self     )    ->					Tuple:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           __lowercase							=						lora_components["""unet_lora_attn_procs"""]
           __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )
           __lowercase							=						sd_pipe.to(lowerCamelCase__     )
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__     )

           __lowercase				,__lowercase				,__lowercase							=						self.get_dummy_inputs()

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						original_images[0, -3:, -3:, -1]

           with tempfile.TemporaryDirectory() as tmpdirname:
               __lowercase							=						sd_pipe.unet
               unet.set_attn_processor(lowerCamelCase__     )
               unet.save_attn_procs(lowerCamelCase__     )
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,		"""pytorch_lora_weights.bin"""     )     )     )
               sd_pipe.load_lora_weights(lowerCamelCase__     )

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						lora_images[0, -3:, -3:, -1]

           # Outputs shouldn't match.
           self.assertFalse(torch.allclose(torch.from_numpy(lowerCamelCase__     )					,		torch.from_numpy(lowerCamelCase__     )     )     )

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

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )

           __lowercase							=						self.get_dummy_tokens()

           # inference without lora
           __lowercase							=						pipe.text_encoder(**lowerCamelCase__     )[0]
           assert outputs_without_lora.shape == (1, 77, 32)

           # create lora_attn_procs with zeroed out up.weights
           __lowercase							=						create_text_encoder_lora_attn_procs(pipe.text_encoder     )
           set_lora_up_weights(lowerCamelCase__					,		randn_weight=lowerCamelCase__     )

           # monkey patch
           pipe._modify_text_encoder(lowerCamelCase__     )

           # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
           del text_attn_procs
           gc.collect()

           # inference with lora
           __lowercase							=						pipe.text_encoder(**lowerCamelCase__     )[0]
           assert outputs_with_lora.shape == (1, 77, 32)

           assert torch.allclose(
               lowerCamelCase__					,		lowerCamelCase__     ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

           # create lora_attn_procs with randn up.weights
           __lowercase							=						create_text_encoder_lora_attn_procs(pipe.text_encoder     )
           set_lora_up_weights(lowerCamelCase__					,		randn_weight=lowerCamelCase__     )

           # monkey patch
           pipe._modify_text_encoder(lowerCamelCase__     )

           # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
           del text_attn_procs
           gc.collect()

           # inference with lora
           __lowercase							=						pipe.text_encoder(**lowerCamelCase__     )[0]
           assert outputs_with_lora.shape == (1, 77, 32)

           assert not torch.allclose(
               lowerCamelCase__					,		lowerCamelCase__     ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"

       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )

           __lowercase							=						self.get_dummy_tokens()

           # inference without lora
           __lowercase							=						pipe.text_encoder(**lowerCamelCase__     )[0]
           assert outputs_without_lora.shape == (1, 77, 32)

           # create lora_attn_procs with randn up.weights
           __lowercase							=						create_text_encoder_lora_attn_procs(pipe.text_encoder     )
           set_lora_up_weights(lowerCamelCase__					,		randn_weight=lowerCamelCase__     )

           # monkey patch
           pipe._modify_text_encoder(lowerCamelCase__     )

           # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
           del text_attn_procs
           gc.collect()

           # inference with lora
           __lowercase							=						pipe.text_encoder(**lowerCamelCase__     )[0]
           assert outputs_with_lora.shape == (1, 77, 32)

           assert not torch.allclose(
               lowerCamelCase__					,		lowerCamelCase__     ), "lora outputs should be different to without lora outputs"

           # remove monkey patch
           pipe._remove_text_encoder_monkey_patch()

           # inference with removed lora
           __lowercase							=						pipe.text_encoder(**lowerCamelCase__     )[0]
           assert outputs_without_lora_removed.shape == (1, 77, 32)

           assert torch.allclose(
               lowerCamelCase__					,		lowerCamelCase__     ), "remove lora monkey patch should restore the original outputs"

       def     snake_case__			(    self     )    ->					Dict:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )
           __lowercase							=						sd_pipe.to(lowerCamelCase__     )
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__     )

           __lowercase				,__lowercase				,__lowercase							=						self.get_dummy_inputs()

           with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=lowerCamelCase__					,		unet_lora_layers=lora_components["""unet_lora_layers"""]					,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]					,		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,		"""pytorch_lora_weights.bin"""     )     )     )
               sd_pipe.load_lora_weights(lowerCamelCase__     )

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						lora_images[0, -3:, -3:, -1]

           __lowercase							=						sd_pipe(**lowerCamelCase__					,		cross_attention_kwargs={"""scale""": 0.5}     ).images
           __lowercase							=						lora_images_with_scale[0, -3:, -3:, -1]

           # Outputs shouldn't match.
           self.assertFalse(
               torch.allclose(torch.from_numpy(lowerCamelCase__     )					,		torch.from_numpy(lowerCamelCase__     )     )     )

       def     snake_case__			(    self     )    ->					Union[str, Any]:

           """simple docstring"""



           with tempfile.TemporaryDirectory() as tmpdirname:
               self.create_lora_weight_file(lowerCamelCase__     )

               __lowercase				,__lowercase							=						self.get_dummy_components()
               __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )
               __lowercase							=						sd_pipe.to(lowerCamelCase__     )
               sd_pipe.set_progress_bar_config(disable=lowerCamelCase__     )

               # check if vanilla attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                   if isinstance(lowerCamelCase__					,		lowerCamelCase__     ):
                       self.assertIsInstance(module.processor					,		(AttnProcessor, AttnProcessor2_0)     )

            # load LoRA weight file
               sd_pipe.load_lora_weights(lowerCamelCase__     )

               # check if lora attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                   if isinstance(lowerCamelCase__					,		lowerCamelCase__     ):
                       __lowercase							=						(
                           LoRAAttnProcessor2_0 if hasattr(lowerCamelCase__					,		"""scaled_dot_product_attention"""     ) else LoRAAttnProcessor
                       )
                       self.assertIsInstance(module.processor					,		lowerCamelCase__     )

       @unittest.skipIf(torch_device != """cuda"""					,		"""This test is supposed to run on GPU"""     )
       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           with tempfile.TemporaryDirectory() as tmpdirname:
               self.create_lora_weight_file(lowerCamelCase__     )

               __lowercase				,__lowercase							=						self.get_dummy_components()
               __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )
               __lowercase							=						sd_pipe.to(lowerCamelCase__     )
               sd_pipe.set_progress_bar_config(disable=lowerCamelCase__     )

               # enable XFormers
               sd_pipe.enable_xformers_memory_efficient_attention()

               # check if xFormers attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                   if isinstance(lowerCamelCase__					,		lowerCamelCase__     ):
                       self.assertIsInstance(module.processor					,		lowerCamelCase__     )

            # load LoRA weight file
               sd_pipe.load_lora_weights(lowerCamelCase__     )

               # check if lora attention processors are used
               for _, module in sd_pipe.unet.named_modules():
                   if isinstance(lowerCamelCase__					,		lowerCamelCase__     ):
                       self.assertIsInstance(module.processor					,		lowerCamelCase__     )




       @unittest.skipIf(torch_device != """cuda"""					,		"""This test is supposed to run on GPU"""     )
       def     snake_case__			(    self     )    ->					List[str]:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.get_dummy_components()
           __lowercase							=						StableDiffusionPipeline(**lowerCamelCase__     )
           __lowercase							=						sd_pipe.to(lowerCamelCase__     )
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__     )

           __lowercase				,__lowercase				,__lowercase							=						self.get_dummy_inputs()

           # enable XFormers
           sd_pipe.enable_xformers_memory_efficient_attention()

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						original_images[0, -3:, -3:, -1]

           with tempfile.TemporaryDirectory() as tmpdirname:
               LoraLoaderMixin.save_lora_weights(
                   save_directory=lowerCamelCase__					,		unet_lora_layers=lora_components["""unet_lora_layers"""]					,		text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]					,		)
               self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,		"""pytorch_lora_weights.bin"""     )     )     )
               sd_pipe.load_lora_weights(lowerCamelCase__     )

           __lowercase							=						sd_pipe(**lowerCamelCase__     ).images
           __lowercase							=						lora_images[0, -3:, -3:, -1]

           # Outputs shouldn't match.
           self.assertFalse(torch.allclose(torch.from_numpy(lowerCamelCase__     )					,		torch.from_numpy(lowerCamelCase__     )     )     )










'''simple docstring'''
from __future__ import annotations

A							:      List[str] 	=       {1: 1}
def 				snake_case_  (   a__		:	int			):



    """simple docstring"""




    if n in COLLATZ_SEQUENCE_LENGTHS:
        return COLLATZ_SEQUENCE_LENGTHS[n]
    __lowercase							=						n // 2 if n % 2 == 0 else 3 * n + 1
    __lowercase							=						collatz_sequence_length(a__			) + 1
    __lowercase							=						sequence_length
    return sequence_length
def 				snake_case_  (   a__		:	int = 1_00_00_00			):



    """simple docstring"""




    __lowercase							=						max((collatz_sequence_length(a__			), i) for i in range(1    ,a__			)			)
    return result[1]


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




