






"""simple docstring"""






A_			  =    [
    [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
    [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
]




def 						_UpperCamelCase			(  A    ,       A    ,       A    ,       A			):
   return 0 <= row < rows and 0 <= col < cols




def 						_UpperCamelCase			(  A    ,       A    ,       A    ,       A			):
   UpperCamelCase_     =len(A			)
   UpperCamelCase_     =len(mat[0]			)
   if is_safe(A    ,       A    ,       A    ,       A			) and (row, col) not in seen and mat[row][col] == 1:
      seen.add((row, col)			)
      return (
          1
          + depth_first_search(row + 1    ,       A    ,       A    ,       A			)
          + depth_first_search(row - 1    ,       A    ,       A    ,       A			)
          + depth_first_search(A    ,       col + 1    ,       A    ,       A			)
          + depth_first_search(A    ,       col - 1    ,       A    ,       A			)
      )
   else:
      return 0




def 						_UpperCamelCase			(  A			):
   UpperCamelCase_     =set()

   UpperCamelCase_     =0
   for row, line in enumerate(A			):
      for col, item in enumerate(A			):
         if item == 1 and (row, col) not in seen:
            # Maximizing the area
            UpperCamelCase_     =max(A    ,       depth_first_search(A    ,       A    ,       A    ,       A			)			)
   return max_area


if __name__ == "__main__":
    import doctest

    print(find_max_area(matrix))  # Output -> 6
    doctest.testmod()








"""simple docstring"""






import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


A_			  =    {512: "DiT-XL-2-512x512.pt", 256: "DiT-XL-2-256x256.pt"}




def 						_UpperCamelCase			(  A			):
   UpperCamelCase_     =f"""pretrained_models/{model_name}"""
   if not os.path.isfile(A			):
      os.makedirs("pretrained_models"    ,       exist_ok=A			)
      UpperCamelCase_     =f"""https://dl.fbaipublicfiles.com/DiT/models/{model_name}"""
      download_url(A    ,       "pretrained_models"			)
   UpperCamelCase_     =torch.load(A    ,       map_location=lambda A    ,       A			: storage			)
   return model




def 						_UpperCamelCase			(  A			):
   UpperCamelCase_     =download_model(pretrained_models[args.image_size]			)

   UpperCamelCase_     =state_dict["x_embedder.proj.weight"]
   UpperCamelCase_     =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_     =state_dict[
          "t_embedder.mlp.0.weight"
      ]
      UpperCamelCase_     =state_dict[
          "t_embedder.mlp.0.bias"
      ]
      UpperCamelCase_     =state_dict[
          "t_embedder.mlp.2.weight"
      ]
      UpperCamelCase_     =state_dict[
          "t_embedder.mlp.2.bias"
      ]
      UpperCamelCase_     =state_dict[
          "y_embedder.embedding_table.weight"
      ]

      UpperCamelCase_     =state_dict[
          f"""blocks.{depth}.adaLN_modulation.1.weight"""
      ]
      UpperCamelCase_     =state_dict[
          f"""blocks.{depth}.adaLN_modulation.1.bias"""
      ]

      UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_     =torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.weight"""]    ,       3    ,       dim=0			)
      UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_     =torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.bias"""]    ,       3    ,       dim=0			)

      UpperCamelCase_     =q
      UpperCamelCase_     =q_bias
      UpperCamelCase_     =k
      UpperCamelCase_     =k_bias
      UpperCamelCase_     =v
      UpperCamelCase_     =v_bias

      UpperCamelCase_     =state_dict[
          f"""blocks.{depth}.attn.proj.weight"""
      ]
      UpperCamelCase_     =state_dict[f"""blocks.{depth}.attn.proj.bias"""]

      UpperCamelCase_     =state_dict[f"""blocks.{depth}.mlp.fc1.weight"""]
      UpperCamelCase_     =state_dict[f"""blocks.{depth}.mlp.fc1.bias"""]
      UpperCamelCase_     =state_dict[f"""blocks.{depth}.mlp.fc2.weight"""]
      UpperCamelCase_     =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_     =state_dict["final_layer.adaLN_modulation.1.weight"]
   UpperCamelCase_     =state_dict["final_layer.adaLN_modulation.1.bias"]
   UpperCamelCase_     =state_dict["final_layer.linear.weight"]
   UpperCamelCase_     =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_     =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=A    ,       num_attention_heads=16    ,       activation_fn="gelu-approximate"    ,       num_embeds_ada_norm=1_000    ,       norm_type="ada_norm_zero"    ,       norm_elementwise_affine=A    ,       )
   transformer.load_state_dict(A    ,       strict=A			)

   UpperCamelCase_     =DDIMScheduler(
       num_train_timesteps=1_000    ,       beta_schedule="linear"    ,       prediction_type="epsilon"    ,       clip_sample=A    ,       )

   UpperCamelCase_     =AutoencoderKL.from_pretrained(args.vae_model			)

   UpperCamelCase_     =DiTPipeline(transformer=A    ,       vae=A    ,       scheduler=A			)

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


if __name__ == "__main__":
    A_			  =    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."
    )

    A_			  =    parser.parse_args()
    main(args)
