





'''simple docstring'''

import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


lowerCAmelCase__      :   List[str]      	=			{5_12: "DiT-XL-2-512x512.pt", 2_56: "DiT-XL-2-256x256.pt"}


def 						__UpperCamelCase						(			_UpperCAmelCase  ):
		__UpperCAmelCase	:							Tuple     =     F"pretrained_models/{model_name}"
		if not os.path.isfile(_UpperCAmelCase  ):
				os.makedirs("pretrained_models",       exist_ok=_UpperCAmelCase  )
				__UpperCAmelCase	:							Optional[Any]     =     F"https://dl.fbaipublicfiles.com/DiT/models/{model_name}"
				download_url(_UpperCAmelCase,       "pretrained_models"  )
		__UpperCAmelCase	:							int     =     torch.load(_UpperCAmelCase,       map_location=lambda _UpperCAmelCase,       _UpperCAmelCase  : storage  )
		return model


def 						__UpperCamelCase						(			_UpperCAmelCase  ):
		__UpperCAmelCase	:							Tuple     =     download_model(pretrained_models[args.image_size]  )

		__UpperCAmelCase	:							List[str]     =     state_dict["x_embedder.proj.weight"]
		__UpperCAmelCase	:							Any     =     state_dict["x_embedder.proj.bias"]
		state_dict.pop("x_embedder.proj.weight"  )
		state_dict.pop("x_embedder.proj.bias"  )

		for depth in range(28  ):
				__UpperCAmelCase	:							List[Any]     =     state_dict[
				    "t_embedder.mlp.0.weight"
				]
				__UpperCAmelCase	:							int     =     state_dict[
				    "t_embedder.mlp.0.bias"
				]
				__UpperCAmelCase	:							int     =     state_dict[
				    "t_embedder.mlp.2.weight"
				]
				__UpperCAmelCase	:							int     =     state_dict[
				    "t_embedder.mlp.2.bias"
				]
				__UpperCAmelCase	:							List[Any]     =     state_dict[
				    "y_embedder.embedding_table.weight"
				]

				__UpperCAmelCase	:							Union[str, Any]     =     state_dict[
				    F"blocks.{depth}.adaLN_modulation.1.weight"
				]
				__UpperCAmelCase	:							List[Any]     =     state_dict[
				    F"blocks.{depth}.adaLN_modulation.1.bias"
				]

				__UpperCAmelCase  ,			__UpperCAmelCase  ,			__UpperCAmelCase	:							Optional[int]     =     torch.chunk(state_dict[F"blocks.{depth}.attn.qkv.weight"],       3,       dim=0  )
				__UpperCAmelCase  ,			__UpperCAmelCase  ,			__UpperCAmelCase	:							int     =     torch.chunk(state_dict[F"blocks.{depth}.attn.qkv.bias"],       3,       dim=0  )

				__UpperCAmelCase	:							Union[str, Any]     =     q
				__UpperCAmelCase	:							Optional[int]     =     q_bias
				__UpperCAmelCase	:							Optional[int]     =     k
				__UpperCAmelCase	:							Union[str, Any]     =     k_bias
				__UpperCAmelCase	:							List[Any]     =     v
				__UpperCAmelCase	:							List[str]     =     v_bias

				__UpperCAmelCase	:							Dict     =     state_dict[
				    F"blocks.{depth}.attn.proj.weight"
				]
				__UpperCAmelCase	:							Optional[int]     =     state_dict[F"blocks.{depth}.attn.proj.bias"]

				__UpperCAmelCase	:							List[Any]     =     state_dict[F"blocks.{depth}.mlp.fc1.weight"]
				__UpperCAmelCase	:							List[Any]     =     state_dict[F"blocks.{depth}.mlp.fc1.bias"]
				__UpperCAmelCase	:							Optional[int]     =     state_dict[F"blocks.{depth}.mlp.fc2.weight"]
				__UpperCAmelCase	:							Tuple     =     state_dict[F"blocks.{depth}.mlp.fc2.bias"]

				state_dict.pop(F"blocks.{depth}.attn.qkv.weight"  )
				state_dict.pop(F"blocks.{depth}.attn.qkv.bias"  )
				state_dict.pop(F"blocks.{depth}.attn.proj.weight"  )
				state_dict.pop(F"blocks.{depth}.attn.proj.bias"  )
				state_dict.pop(F"blocks.{depth}.mlp.fc1.weight"  )
				state_dict.pop(F"blocks.{depth}.mlp.fc1.bias"  )
				state_dict.pop(F"blocks.{depth}.mlp.fc2.weight"  )
				state_dict.pop(F"blocks.{depth}.mlp.fc2.bias"  )
				state_dict.pop(F"blocks.{depth}.adaLN_modulation.1.weight"  )
				state_dict.pop(F"blocks.{depth}.adaLN_modulation.1.bias"  )

		state_dict.pop("t_embedder.mlp.0.weight"  )
		state_dict.pop("t_embedder.mlp.0.bias"  )
		state_dict.pop("t_embedder.mlp.2.weight"  )
		state_dict.pop("t_embedder.mlp.2.bias"  )
		state_dict.pop("y_embedder.embedding_table.weight"  )

		__UpperCAmelCase	:							Any     =     state_dict["final_layer.adaLN_modulation.1.weight"]
		__UpperCAmelCase	:							Tuple     =     state_dict["final_layer.adaLN_modulation.1.bias"]
		__UpperCAmelCase	:							List[Any]     =     state_dict["final_layer.linear.weight"]
		__UpperCAmelCase	:							Union[str, Any]     =     state_dict["final_layer.linear.bias"]

		state_dict.pop("final_layer.linear.weight"  )
		state_dict.pop("final_layer.linear.bias"  )
		state_dict.pop("final_layer.adaLN_modulation.1.weight"  )
		state_dict.pop("final_layer.adaLN_modulation.1.bias"  )

		# DiT XL/2
		__UpperCAmelCase	:							Union[str, Any]     =     TransformeraDModel(
		    sample_size=args.image_size // 8,       num_layers=28,       attention_head_dim=72,       in_channels=4,       out_channels=8,       patch_size=2,       attention_bias=_UpperCAmelCase,       num_attention_heads=16,       activation_fn="gelu-approximate",       num_embeds_ada_norm=1000,       norm_type="ada_norm_zero",       norm_elementwise_affine=_UpperCAmelCase,       )
		transformer.load_state_dict(_UpperCAmelCase,       strict=_UpperCAmelCase  )

		__UpperCAmelCase	:							int     =     DDIMScheduler(
		    num_train_timesteps=1000,       beta_schedule="linear",       prediction_type="epsilon",       clip_sample=_UpperCAmelCase,       )

		__UpperCAmelCase	:							List[str]     =     AutoencoderKL.from_pretrained(args.vae_model  )

		__UpperCAmelCase	:							Optional[Any]     =     DiTPipeline(transformer=_UpperCAmelCase,       vae=_UpperCAmelCase,       scheduler=_UpperCAmelCase  )

		if args.save:
				pipeline.save_pretrained(args.checkpoint_path  )


if __name__ == "__main__":
			lowerCAmelCase__      :   Optional[int]      	=			argparse.ArgumentParser()

			parser.add_argument(
			    "--image_size",
			    default=2_56,
			    type=int,
			    required=False,
			    help="Image size of pretrained model, either 256 or 512.",
			)
			parser.add_argument(
			    "--vae_model",
			    default="stabilityai/sd-vae-ft-ema",
			    type=str,
			    required=False,
			    help="Path to pretrained VAE model, either stabilityai/sd-vae-ft-mse or stabilityai/sd-vae-ft-ema.",
			)
			parser.add_argument(
			    "--save", default=True, type=bool, required=False, help="Whether to save the converted pipeline or not."
			)
			parser.add_argument(
			    "--checkpoint_path", default=None, type=str, required=True, help="Path to the output pipeline."
			)

			lowerCAmelCase__      :   Dict      	=			parser.parse_args()
			main(args)











'''simple docstring'''

from __future__ import annotations

lowerCAmelCase__      :   Tuple      	=			{1: 1}


def 						__UpperCamelCase						(			_UpperCAmelCase  ):
		if n in COLLATZ_SEQUENCE_LENGTHS:
				return COLLATZ_SEQUENCE_LENGTHS[n]
		__UpperCAmelCase	:							int     =     n // 2 if n % 2 == 0 else 3 * n + 1
		__UpperCAmelCase	:							str     =     collatz_sequence_length(_UpperCAmelCase  ) + 1
		__UpperCAmelCase	:							Union[str, Any]     =     sequence_length
		return sequence_length


def 						__UpperCamelCase						(			_UpperCAmelCase = 1000000  ):
		__UpperCAmelCase	:							Union[str, Any]     =     max((collatz_sequence_length(_UpperCAmelCase  ), i) for i in range(1,       _UpperCAmelCase  )  )
		return result[1]


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




