






"""simple docstring"""



import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


_lowerCAmelCase     :     Optional[Any]            =	{512: """DiT-XL-2-512x512.pt""", 256: """DiT-XL-2-256x256.pt"""}


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Union[str, Any]							)->						str:






     '''simple docstring'''



     UpperCAmelCase__		:  Optional[Any]				=				f'pretrained_models/{model_name}'
     if not os.path.isfile(snake_case							):
          os.makedirs("pretrained_models"       , exist_ok=snake_case							)
          UpperCAmelCase__		:  Any				=				f'https://dl.fbaipublicfiles.com/DiT/models/{model_name}'
          download_url(snake_case       , "pretrained_models"							)
     UpperCAmelCase__		:  str				=				torch.load(snake_case       , map_location=lambda snake_case       , snake_case							: storage							)
     return model


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Optional[int]							)->						int:






     '''simple docstring'''



     UpperCAmelCase__		:  List[Any]				=				download_model(pretrained_models[args.image_size]							)

     UpperCAmelCase__		:  Dict				=				state_dict["x_embedder.proj.weight"]
     UpperCAmelCase__		:  List[str]				=				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__		:  Optional[Any]				=				state_dict[
              "t_embedder.mlp.0.weight"
          ]
          UpperCAmelCase__		:  Union[str, Any]				=				state_dict[
              "t_embedder.mlp.0.bias"
          ]
          UpperCAmelCase__		:  List[Any]				=				state_dict[
              "t_embedder.mlp.2.weight"
          ]
          UpperCAmelCase__		:  Dict				=				state_dict[
              "t_embedder.mlp.2.bias"
          ]
          UpperCAmelCase__		:  int				=				state_dict[
              "y_embedder.embedding_table.weight"
          ]

          UpperCAmelCase__		:  Optional[Any]				=				state_dict[
              f'blocks.{depth}.adaLN_modulation.1.weight'
          ]
          UpperCAmelCase__		:  List[str]				=				state_dict[
              f'blocks.{depth}.adaLN_modulation.1.bias'
          ]

          UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  str				=				torch.chunk(state_dict[f'blocks.{depth}.attn.qkv.weight']       , 3       , dim=0							)
          UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  List[str]				=				torch.chunk(state_dict[f'blocks.{depth}.attn.qkv.bias']       , 3       , dim=0							)

          UpperCAmelCase__		:  Union[str, Any]				=				q
          UpperCAmelCase__		:  str				=				q_bias
          UpperCAmelCase__		:  Union[str, Any]				=				k
          UpperCAmelCase__		:  str				=				k_bias
          UpperCAmelCase__		:  Optional[Any]				=				v
          UpperCAmelCase__		:  Any				=				v_bias

          UpperCAmelCase__		:  List[str]				=				state_dict[
              f'blocks.{depth}.attn.proj.weight'
          ]
          UpperCAmelCase__		:  Dict				=				state_dict[f'blocks.{depth}.attn.proj.bias']

          UpperCAmelCase__		:  Union[str, Any]				=				state_dict[f'blocks.{depth}.mlp.fc1.weight']
          UpperCAmelCase__		:  Optional[int]				=				state_dict[f'blocks.{depth}.mlp.fc1.bias']
          UpperCAmelCase__		:  int				=				state_dict[f'blocks.{depth}.mlp.fc2.weight']
          UpperCAmelCase__		:  List[str]				=				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__		:  Any				=				state_dict["final_layer.adaLN_modulation.1.bias"]
     UpperCAmelCase__		:  Dict				=				state_dict["final_layer.linear.weight"]
     UpperCAmelCase__		:  List[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=snake_case       , num_attention_heads=16       , activation_fn="gelu-approximate"       , num_embeds_ada_norm=1000       , norm_type="ada_norm_zero"       , norm_elementwise_affine=snake_case       , )
     transformer.load_state_dict(snake_case       , strict=snake_case							)

     UpperCAmelCase__		:  List[str]				=				DDIMScheduler(
         num_train_timesteps=1000       , beta_schedule="linear"       , prediction_type="epsilon"       , clip_sample=snake_case       , )

     UpperCAmelCase__		:  Optional[int]				=				AutoencoderKL.from_pretrained(args.vae_model							)

     UpperCAmelCase__		:  Optional[Any]				=				DiTPipeline(transformer=snake_case       , vae=snake_case       , scheduler=snake_case							)

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


if __name__ == "__main__":
 _lowerCAmelCase     :     Optional[Any]            =	argparse.ArgumentParser()

 parser.add_argument(
     """--image_size""",
     default=256,
     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     :     int            =	parser.parse_args()
 main(args)




"""simple docstring"""


import itertools



def     _lowerCamelCase(__UpperCamelCase       )				-> List[str]:
	return (
	    int("""""".join(combination[0:2]       )       ) * int("""""".join(combination[2:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	) or (
	    int("""""".join(combination[0]       )       ) * int("""""".join(combination[1:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	)



def     _lowerCamelCase()				-> Dict:
	return sum(
	    {
	        int("""""".join(pandigital[5:9]       )       )
	        for pandigital in itertools.permutations("""123456789"""       )
	        if is_combination_valid(__UpperCamelCase       )
	    }       )


if __name__ == "__main__":
			print(solution())



