

"""simple docstring"""




from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block


@dataclass
class 		_A							(      __a       ):
      __a             =						42






class 		_A							(      __a					,							__a       ):





      @register_to_config
      def __init__(	self     ,    SCREAMING_SNAKE_CASE__ = None     ,    SCREAMING_SNAKE_CASE__ = 3     ,    SCREAMING_SNAKE_CASE__ = 3     ,    SCREAMING_SNAKE_CASE__ = False     ,    SCREAMING_SNAKE_CASE__ = "positional"     ,    SCREAMING_SNAKE_CASE__ = 0     ,    SCREAMING_SNAKE_CASE__ = True     ,    SCREAMING_SNAKE_CASE__ = ("DownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D")     ,    SCREAMING_SNAKE_CASE__ = ("AttnUpBlock2D", "AttnUpBlock2D", "AttnUpBlock2D", "UpBlock2D")     ,    SCREAMING_SNAKE_CASE__ = (224, 448, 672, 896)     ,    SCREAMING_SNAKE_CASE__ = 2     ,    SCREAMING_SNAKE_CASE__ = 1     ,    SCREAMING_SNAKE_CASE__ = 1     ,    SCREAMING_SNAKE_CASE__ = "conv"     ,    SCREAMING_SNAKE_CASE__ = "conv"     ,    SCREAMING_SNAKE_CASE__ = "silu"     ,    SCREAMING_SNAKE_CASE__ = 8     ,    SCREAMING_SNAKE_CASE__ = 32     ,    SCREAMING_SNAKE_CASE__ = 1e-5     ,    SCREAMING_SNAKE_CASE__ = "default"     ,    SCREAMING_SNAKE_CASE__ = True     ,    SCREAMING_SNAKE_CASE__ = None     ,    SCREAMING_SNAKE_CASE__ = None     ,    ) ->       Dict:
         super().__init__()

         lowerCamelCase__						       =      sample_size
         lowerCamelCase__						       =      block_out_channels[0] * 4

         # Check inputs
         if len(SCREAMING_SNAKE_CASE__		) != len(SCREAMING_SNAKE_CASE__		):
            raise ValueError(
                f'Must provide the same number of `down_block_types` as `up_block_types`. `down_block_types`: {down_block_types}. `up_block_types`: {up_block_types}.'		)

         if len(SCREAMING_SNAKE_CASE__		) != len(SCREAMING_SNAKE_CASE__		):
            raise ValueError(
                f'Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}.'		)

         # input
         lowerCamelCase__						       =      nn.Convad(SCREAMING_SNAKE_CASE__     ,    block_out_channels[0]     ,    kernel_size=3     ,    padding=(1, 1)		)

         # time
         if time_embedding_type == "fourier":
            lowerCamelCase__						       =      GaussianFourierProjection(embedding_size=block_out_channels[0]     ,    scale=16		)
            lowerCamelCase__						       =      2 * block_out_channels[0]
         elif time_embedding_type == "positional":
            lowerCamelCase__						       =      Timesteps(block_out_channels[0]     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)
            lowerCamelCase__						       =      block_out_channels[0]

         lowerCamelCase__						       =      TimestepEmbedding(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)

         # class embedding
         if class_embed_type is None and num_class_embeds is not None:
            lowerCamelCase__						       =      nn.Embedding(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)
         elif class_embed_type == "timestep":
            lowerCamelCase__						       =      TimestepEmbedding(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)
         elif class_embed_type == "identity":
            lowerCamelCase__						       =      nn.Identity(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)
         else:
            lowerCamelCase__						       =      None

         lowerCamelCase__						       =      nn.ModuleList([]		)
         lowerCamelCase__						       =      None
         lowerCamelCase__						       =      nn.ModuleList([]		)

         # down
         lowerCamelCase__						       =      block_out_channels[0]
         for i, down_block_type in enumerate(SCREAMING_SNAKE_CASE__		):
            lowerCamelCase__						       =      output_channel
            lowerCamelCase__						       =      block_out_channels[i]
            lowerCamelCase__						       =      i == len(SCREAMING_SNAKE_CASE__		) - 1

            lowerCamelCase__						       =      get_down_block(
                SCREAMING_SNAKE_CASE__     ,    num_layers=SCREAMING_SNAKE_CASE__     ,    in_channels=SCREAMING_SNAKE_CASE__     ,    out_channels=SCREAMING_SNAKE_CASE__     ,    temb_channels=SCREAMING_SNAKE_CASE__     ,    add_downsample=not is_final_block     ,    resnet_eps=SCREAMING_SNAKE_CASE__     ,    resnet_act_fn=SCREAMING_SNAKE_CASE__     ,    resnet_groups=SCREAMING_SNAKE_CASE__     ,    attention_head_dim=attention_head_dim if attention_head_dim is not None else output_channel     ,    downsample_padding=SCREAMING_SNAKE_CASE__     ,    resnet_time_scale_shift=SCREAMING_SNAKE_CASE__     ,    downsample_type=SCREAMING_SNAKE_CASE__     ,    )
            self.down_blocks.append(SCREAMING_SNAKE_CASE__		)

         # mid
         lowerCamelCase__						       =      UNetMidBlockaD(
             in_channels=block_out_channels[-1]     ,    temb_channels=SCREAMING_SNAKE_CASE__     ,    resnet_eps=SCREAMING_SNAKE_CASE__     ,    resnet_act_fn=SCREAMING_SNAKE_CASE__     ,    output_scale_factor=SCREAMING_SNAKE_CASE__     ,    resnet_time_scale_shift=SCREAMING_SNAKE_CASE__     ,    attention_head_dim=attention_head_dim if attention_head_dim is not None else block_out_channels[-1]     ,    resnet_groups=SCREAMING_SNAKE_CASE__     ,    add_attention=SCREAMING_SNAKE_CASE__     ,    )

         # up
         lowerCamelCase__						       =      list(reversed(SCREAMING_SNAKE_CASE__		)		)
         lowerCamelCase__						       =      reversed_block_out_channels[0]
         for i, up_block_type in enumerate(SCREAMING_SNAKE_CASE__		):
            lowerCamelCase__						       =      output_channel
            lowerCamelCase__						       =      reversed_block_out_channels[i]
            lowerCamelCase__						       =      reversed_block_out_channels[min(i + 1     ,    len(SCREAMING_SNAKE_CASE__		) - 1		)]

            lowerCamelCase__						       =      i == len(SCREAMING_SNAKE_CASE__		) - 1

            lowerCamelCase__						       =      get_up_block(
                SCREAMING_SNAKE_CASE__     ,    num_layers=layers_per_block + 1     ,    in_channels=SCREAMING_SNAKE_CASE__     ,    out_channels=SCREAMING_SNAKE_CASE__     ,    prev_output_channel=SCREAMING_SNAKE_CASE__     ,    temb_channels=SCREAMING_SNAKE_CASE__     ,    add_upsample=not is_final_block     ,    resnet_eps=SCREAMING_SNAKE_CASE__     ,    resnet_act_fn=SCREAMING_SNAKE_CASE__     ,    resnet_groups=SCREAMING_SNAKE_CASE__     ,    attention_head_dim=attention_head_dim if attention_head_dim is not None else output_channel     ,    resnet_time_scale_shift=SCREAMING_SNAKE_CASE__     ,    upsample_type=SCREAMING_SNAKE_CASE__     ,    )
            self.up_blocks.append(SCREAMING_SNAKE_CASE__		)
            lowerCamelCase__						       =      output_channel

         # out
         lowerCamelCase__						       =      norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4     ,    32		)
         lowerCamelCase__						       =      nn.GroupNorm(num_channels=block_out_channels[0]     ,    num_groups=SCREAMING_SNAKE_CASE__     ,    eps=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      nn.SiLU()
         lowerCamelCase__						       =      nn.Convad(block_out_channels[0]     ,    SCREAMING_SNAKE_CASE__     ,    kernel_size=3     ,    padding=1		)





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__ = None     ,    SCREAMING_SNAKE_CASE__ = True     ,    ) ->       Union[UNetaDOutput, Tuple]:
         # 0. center input if necessary
         if self.config.center_input_sample:
            lowerCamelCase__						       =      2 * sample - 1.0

         # 1. time
         lowerCamelCase__						       =      timestep
         if not torch.is_tensor(SCREAMING_SNAKE_CASE__		):
            lowerCamelCase__						       =      torch.tensor([timesteps]     ,    dtype=torch.long     ,    device=sample.device		)
         elif torch.is_tensor(SCREAMING_SNAKE_CASE__		) and len(timesteps.shape		) == 0:
            lowerCamelCase__						       =      timesteps[None].to(sample.device		)

         # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
         lowerCamelCase__						       =      timesteps * torch.ones(sample.shape[0]     ,    dtype=timesteps.dtype     ,    device=timesteps.device		)

         lowerCamelCase__						       =      self.time_proj(SCREAMING_SNAKE_CASE__		)

         # timesteps does not contain any weights and will always return f32 tensors
         # but time_embedding might actually be running in fp16. so we need to cast here.
         # there might be better ways to encapsulate this.
         lowerCamelCase__						       =      t_emb.to(dtype=self.dtype		)
         lowerCamelCase__						       =      self.time_embedding(SCREAMING_SNAKE_CASE__		)

         if self.class_embedding is not None:
            if class_labels is None:
               raise ValueError("class_labels should be provided when doing class conditioning"		)

            if self.config.class_embed_type == "timestep":
               lowerCamelCase__						       =      self.time_proj(SCREAMING_SNAKE_CASE__		)

            lowerCamelCase__						       =      self.class_embedding(SCREAMING_SNAKE_CASE__		).to(dtype=self.dtype		)
            lowerCamelCase__						       =      emb + class_emb

         # 2. pre-process
         lowerCamelCase__						       =      sample
         lowerCamelCase__						       =      self.conv_in(SCREAMING_SNAKE_CASE__		)

         # 3. down
         lowerCamelCase__						       =      (sample,)
         for downsample_block in self.down_blocks:
            if hasattr(SCREAMING_SNAKE_CASE__     ,    "skip_conv"		):
               lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__						       =      downsample_block(
                   hidden_states=SCREAMING_SNAKE_CASE__     ,    temb=SCREAMING_SNAKE_CASE__     ,    skip_sample=SCREAMING_SNAKE_CASE__		)
            else:
               lowerCamelCase__       ,							lowerCamelCase__						       =      downsample_block(hidden_states=SCREAMING_SNAKE_CASE__     ,    temb=SCREAMING_SNAKE_CASE__		)

            down_block_res_samples += res_samples

         # 4. mid
         lowerCamelCase__						       =      self.mid_block(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)

         # 5. up
         lowerCamelCase__						       =      None
         for upsample_block in self.up_blocks:
            lowerCamelCase__						       =      down_block_res_samples[-len(upsample_block.resnets		) :]
            lowerCamelCase__						       =      down_block_res_samples[: -len(upsample_block.resnets		)]

            if hasattr(SCREAMING_SNAKE_CASE__     ,    "skip_conv"		):
               lowerCamelCase__       ,							lowerCamelCase__						       =      upsample_block(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)
            else:
               lowerCamelCase__						       =      upsample_block(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		)

        # 6. post-process
         lowerCamelCase__						       =      self.conv_norm_out(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      self.conv_act(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      self.conv_out(SCREAMING_SNAKE_CASE__		)

         if skip_sample is not None:
            sample += skip_sample

         if self.config.time_embedding_type == "fourier":
            lowerCamelCase__						       =      timesteps.reshape((sample.shape[0], *([1] * len(sample.shape[1:]		)))		)
            lowerCamelCase__						       =      sample / timesteps

         if not return_dict:
            return (sample,)

         return UNetaDOutput(sample=SCREAMING_SNAKE_CASE__		)







"""simple docstring"""




from __future__ import annotations

import math
from itertools import permutations



def 						UpperCAmelCase__ (					A__ )   ->   bool:




   """simple docstring"""

   if 1 < number < 4:
      # 2 and 3 are primes
      return True
   elif number < 2 or number % 2 == 0 or number % 3 == 0:
      # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
      return False

   # All primes number are in format of 6k +/- 1
   for i in range(5						,     int(math.sqrt(A__ ) + 1 )						,     6 ):
      if number % i == 0 or number % (i + 2) == 0:
         return False
   return True



def 						UpperCAmelCase__ (					A__ = 7 )   ->   int:




   """simple docstring"""
   lowerCamelCase__						       =      "".join(str(A__ ) for i in range(1						,     n + 1 ) )
   lowerCamelCase__						       =      [int("".join(A__ ) ) for i in permutations(A__						,     A__ )]
   lowerCamelCase__						       =      [num for num in perm_list if is_prime(A__ )]
   return max(A__ ) if pandigitals else 0


if __name__ == "__main__":
     print(F'''{solution() = }''')




