




import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


UpperCAmelCase__						:       Union[str, Any]							=    {512: 'DiT-XL-2-512x512.pt', 256: 'DiT-XL-2-256x256.pt'}


def 		_lowerCamelCase				(					UpperCamelCase							)			->		Optional[int]:





  """simple docstring"""





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


def 		_lowerCamelCase				(					UpperCamelCase							)			->		List[Any]:





  """simple docstring"""





  _lowercase: str						     =    download_model(pretrained_models[args.image_size]							)

  _lowercase: Any						     =    state_dict['x_embedder.proj.weight']
  _lowercase: 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							):
    _lowercase: Tuple						     =    state_dict[
        't_embedder.mlp.0.weight'
    ]
    _lowercase: Dict						     =    state_dict[
        't_embedder.mlp.0.bias'
    ]
    _lowercase: str						     =    state_dict[
        't_embedder.mlp.2.weight'
    ]
    _lowercase: List[str]						     =    state_dict[
        't_embedder.mlp.2.bias'
    ]
    _lowercase: Tuple						     =    state_dict[
        'y_embedder.embedding_table.weight'
    ]

    _lowercase: Tuple						     =    state_dict[
        F'blocks.{depth}.adaLN_modulation.1.weight'
    ]
    _lowercase: Optional[Any]						     =    state_dict[
        F'blocks.{depth}.adaLN_modulation.1.bias'
    ]

    _lowercase: Union[str, Any]						     =    torch.chunk(state_dict[F'blocks.{depth}.attn.qkv.weight']					,     3					,     dim=0							)
    _lowercase: Dict						     =    torch.chunk(state_dict[F'blocks.{depth}.attn.qkv.bias']					,     3					,     dim=0							)

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

    _lowercase: List[Any]						     =    state_dict[
        F'blocks.{depth}.attn.proj.weight'
    ]
    _lowercase: Dict						     =    state_dict[F'blocks.{depth}.attn.proj.bias']

    _lowercase: Any						     =    state_dict[F'blocks.{depth}.mlp.fc1.weight']
    _lowercase: Optional[Any]						     =    state_dict[F'blocks.{depth}.mlp.fc1.bias']
    _lowercase: Union[str, Any]						     =    state_dict[F'blocks.{depth}.mlp.fc2.weight']
    _lowercase: int						     =    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'							)

  _lowercase: Optional[int]						     =    state_dict['final_layer.adaLN_modulation.1.weight']
  _lowercase: Dict						     =    state_dict['final_layer.adaLN_modulation.1.bias']
  _lowercase: int						     =    state_dict['final_layer.linear.weight']
  _lowercase: 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
  _lowercase: 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=1_000					,     norm_type='ada_norm_zero'					,     norm_elementwise_affine=UpperCamelCase					,     )
  transformer.load_state_dict(UpperCamelCase					,     strict=UpperCamelCase							)

  _lowercase: Dict						     =    DDIMScheduler(
      num_train_timesteps=1_000					,     beta_schedule='linear'					,     prediction_type='epsilon'					,     clip_sample=UpperCamelCase					,     )

  _lowercase: Dict						     =    AutoencoderKL.from_pretrained(args.vae_model							)

  _lowercase: Optional[Any]						     =    DiTPipeline(transformer=UpperCamelCase					,     vae=UpperCamelCase					,     scheduler=UpperCamelCase							)

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


if __name__ == "__main__":
   UpperCAmelCase__						:       Union[str, 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.'
   )

   UpperCAmelCase__						:       List[Any]							=    parser.parse_args()
   main(args)






import math


def 		_lowerCamelCase				(					UpperCamelCase							)			->		int:





  """simple docstring"""





  return sum(int(UpperCamelCase							) for digit in str(UpperCamelCase							)							)


def 		_lowerCamelCase				(					UpperCamelCase = 30							)			->		int:





  """simple docstring"""





  _lowercase: int						     =    []
  for digit in range(2					,     100							):
    for power in range(2					,     100							):
      _lowercase: int						     =    int(math.pow(UpperCamelCase					,     UpperCamelCase							)							)
      if digit == digit_sum(UpperCamelCase							):
        digit_to_powers.append(UpperCamelCase							)

  digit_to_powers.sort()
  return digit_to_powers[n - 1]


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