code: 
  
  
  
  
  from dataclasses import dataclass
  from typing import Any, Dict, Optional
  
  import torch
  import torch.nn.functional as F
  from torch import nn
  
  from ..configuration_utils import ConfigMixin, register_to_config
  from ..models.embeddings import ImagePositionalEmbeddings
  from ..utils import BaseOutput, deprecate
  from .attention import BasicTransformerBlock
  from .embeddings import PatchEmbed
  from .modeling_utils import ModelMixin
  
  
  @dataclass
  class 							_lowerCAmelCase		(     UpperCamelCase__	):
  				lowerCamelCase__									=    42
  
  
  
  
  
  
  
  class 							_lowerCAmelCase		(     UpperCamelCase__  ,   UpperCamelCase__	):
  
  
  
  
  				@register_to_config
  				def __init__( self		,		snake_case_ = 16		,		snake_case_ = 88		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = 1		,		snake_case_ = 0.0		,		snake_case_ = 32		,		snake_case_ = None		,		snake_case_ = False		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = "geglu"		,		snake_case_ = None		,		snake_case_ = False		,		snake_case_ = False		,		snake_case_ = False		,		snake_case_ = "layer_norm"		,		snake_case_ = True		,		)    ->      Tuple:
  											super().__init__()
  											SCREAMING_SNAKE_CASE			: Optional[int]	     =use_linear_projection
  											SCREAMING_SNAKE_CASE			: List[Any]	     =num_attention_heads
  											SCREAMING_SNAKE_CASE			: int	     =attention_head_dim
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =num_attention_heads * attention_head_dim
  
  											# 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
  											# Define whether input is continuous or discrete depending on configuration
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =(in_channels is not None) and (patch_size is None)
  											SCREAMING_SNAKE_CASE			: List[str]	     =num_vector_embeds is not None
  											SCREAMING_SNAKE_CASE			: Any	     =in_channels is not None and patch_size is not None
  
  											if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
  																		SCREAMING_SNAKE_CASE			: int	     =(
  																		    F'The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or'
  																		    ''' incorrectly set to `\'layer_norm\'`.Make sure to set `norm_type` to `\'ada_norm\'` in the config.'''
  																		    ''' Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect'''
  																		    ''' results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it'''
  																		    ''' would be very nice if you could open a Pull request for the `transformer/config.json` file'''
  																		)
  																		deprecate('''norm_type!=num_embeds_ada_norm'''		,		'''1.0.0'''		,		snake_case_		,		standard_warn=snake_case_							)
  																		SCREAMING_SNAKE_CASE			: int	     ='''ada_norm'''
  
  											if self.is_input_continuous and self.is_input_vectorized:
  																		raise ValueError(
  																		    F'Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make'
  																		    ''' sure that either `in_channels` or `num_vector_embeds` is None.'''							)
  											elif self.is_input_vectorized and self.is_input_patches:
  																		raise ValueError(
  																		    F'Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make'
  																		    ''' sure that either `num_vector_embeds` or `num_patches` is None.'''							)
  											elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
  																		raise ValueError(
  																		    F'Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:'
  																		    F' {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None.'							)
  
  											# 2. Define input layers
  											if self.is_input_continuous:
  																		SCREAMING_SNAKE_CASE			: Optional[int]	     =in_channels
  
  																		SCREAMING_SNAKE_CASE			: int	     =torch.nn.GroupNorm(num_groups=snake_case_		,		num_channels=snake_case_		,		eps=1E-6		,		affine=snake_case_							)
  																		if use_linear_projection:
  																									SCREAMING_SNAKE_CASE			: Dict	     =nn.Linear(snake_case_		,		snake_case_							)
  																		else:
  																									SCREAMING_SNAKE_CASE			: Optional[Any]	     =nn.Convad(snake_case_		,		snake_case_		,		kernel_size=1		,		stride=1		,		padding=0							)
  											elif self.is_input_vectorized:
  																		assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
  																		assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"
  
  																		SCREAMING_SNAKE_CASE			: Any	     =sample_size
  																		SCREAMING_SNAKE_CASE			: Union[str, Any]	     =sample_size
  																		SCREAMING_SNAKE_CASE			: int	     =num_vector_embeds
  																		SCREAMING_SNAKE_CASE			: List[Any]	     =self.height * self.width
  
  																		SCREAMING_SNAKE_CASE			: Dict	     =ImagePositionalEmbeddings(
  																		    num_embed=snake_case_		,		embed_dim=snake_case_		,		height=self.height		,		width=self.width							)
  											elif self.is_input_patches:
  																		assert sample_size is not None, "Transformer2DModel over patched input must provide sample_size"
  
  																		SCREAMING_SNAKE_CASE			: Tuple	     =sample_size
  																		SCREAMING_SNAKE_CASE			: Optional[int]	     =sample_size
  
  																		SCREAMING_SNAKE_CASE			: Optional[Any]	     =patch_size
  																		SCREAMING_SNAKE_CASE			: Optional[Any]	     =PatchEmbed(
  																		    height=snake_case_		,		width=snake_case_		,		patch_size=snake_case_		,		in_channels=snake_case_		,		embed_dim=snake_case_		,		)
  
  											# 3. Define transformers blocks
  											SCREAMING_SNAKE_CASE			: Any	     =nn.ModuleList(
  											    [
  											        BasicTransformerBlock(
  											            snake_case_		,		snake_case_		,		snake_case_		,		dropout=snake_case_		,		cross_attention_dim=snake_case_		,		activation_fn=snake_case_		,		num_embeds_ada_norm=snake_case_		,		attention_bias=snake_case_		,		only_cross_attention=snake_case_		,		upcast_attention=snake_case_		,		norm_type=snake_case_		,		norm_elementwise_affine=snake_case_		,		)
  											        for d in range(snake_case_							)
  											    ]							)
  
  											# 4. Define output layers
  											SCREAMING_SNAKE_CASE			: List[Any]	     =in_channels if out_channels is None else out_channels
  											if self.is_input_continuous:
  																		# TODO: should use out_channels for continuous projections
  																		if use_linear_projection:
  																									SCREAMING_SNAKE_CASE			: Union[str, Any]	     =nn.Linear(snake_case_		,		snake_case_							)
  																		else:
  																									SCREAMING_SNAKE_CASE			: List[Any]	     =nn.Convad(snake_case_		,		snake_case_		,		kernel_size=1		,		stride=1		,		padding=0							)
  											elif self.is_input_vectorized:
  																		SCREAMING_SNAKE_CASE			: Optional[int]	     =nn.LayerNorm(snake_case_							)
  																		SCREAMING_SNAKE_CASE			: Any	     =nn.Linear(snake_case_		,		self.num_vector_embeds - 1							)
  											elif self.is_input_patches:
  																		SCREAMING_SNAKE_CASE			: Any	     =nn.LayerNorm(snake_case_		,		elementwise_affine=snake_case_		,		eps=1E-6							)
  																		SCREAMING_SNAKE_CASE			: Any	     =nn.Linear(snake_case_		,		2 * inner_dim							)
  																		SCREAMING_SNAKE_CASE			: List[Any]	     =nn.Linear(snake_case_		,		patch_size * patch_size * self.out_channels							)
  
  
  
  
  
  
  
  				def     __a		( self		,		snake_case_		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = True		,		)    ->      Tuple:
  											# ensure attention_mask is a bias, and give it a singleton query_tokens dimension.
  											#   we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward.
  											#   we can tell by counting dims; if ndim == 2: it's a mask rather than a bias.
  											# expects mask of shape:
  											#   [batch, key_tokens]
  											# adds singleton query_tokens dimension:
  											#   [batch,                    1, key_tokens]
  											# this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
  											#   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
  											#   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
  											if attention_mask is not None and attention_mask.ndim == 2:
  																		# assume that mask is expressed as:
  																		#   (1 = keep,      0 = discard)
  																		# convert mask into a bias that can be added to attention scores:
  																		#       (keep = +0,     discard = -10000.0)
  																		SCREAMING_SNAKE_CASE			: Tuple	     =(1 - attention_mask.to(hidden_states.dtype							)) * -1_0000.0
  																		SCREAMING_SNAKE_CASE			: List[str]	     =attention_mask.unsqueeze(1							)
  
  											# convert encoder_attention_mask to a bias the same way we do for attention_mask
  											if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
  																		SCREAMING_SNAKE_CASE			: str	     =(1 - encoder_attention_mask.to(hidden_states.dtype							)) * -1_0000.0
  																		SCREAMING_SNAKE_CASE			: List[str]	     =encoder_attention_mask.unsqueeze(1							)
  
  											# 1. Input
  											if self.is_input_continuous:
  																		SCREAMING_SNAKE_CASE     ,							SCREAMING_SNAKE_CASE     ,							SCREAMING_SNAKE_CASE     ,							SCREAMING_SNAKE_CASE			: str	     =hidden_states.shape
  																		SCREAMING_SNAKE_CASE			: Any	     =hidden_states
  
  																		SCREAMING_SNAKE_CASE			: str	     =self.norm(snake_case_							)
  																		if not self.use_linear_projection:
  																									SCREAMING_SNAKE_CASE			: int	     =self.proj_in(snake_case_							)
  																									SCREAMING_SNAKE_CASE			: int	     =hidden_states.shape[1]
  																									SCREAMING_SNAKE_CASE			: int	     =hidden_states.permute(0		,		2		,		3		,		1							).reshape(snake_case_		,		height * width		,		snake_case_							)
  																		else:
  																									SCREAMING_SNAKE_CASE			: Dict	     =hidden_states.shape[1]
  																									SCREAMING_SNAKE_CASE			: Optional[int]	     =hidden_states.permute(0		,		2		,		3		,		1							).reshape(snake_case_		,		height * width		,		snake_case_							)
  																									SCREAMING_SNAKE_CASE			: Optional[Any]	     =self.proj_in(snake_case_							)
  											elif self.is_input_vectorized:
  																		SCREAMING_SNAKE_CASE			: int	     =self.latent_image_embedding(snake_case_							)
  											elif self.is_input_patches:
  																		SCREAMING_SNAKE_CASE			: Optional[int]	     =self.pos_embed(snake_case_							)
  
  											# 2. Blocks
  											for block in self.transformer_blocks:
  																		SCREAMING_SNAKE_CASE			: Tuple	     =block(
  																		    snake_case_		,		attention_mask=snake_case_		,		encoder_hidden_states=snake_case_		,		encoder_attention_mask=snake_case_		,		timestep=snake_case_		,		cross_attention_kwargs=snake_case_		,		class_labels=snake_case_		,		)
  
  											# 3. Output
  											if self.is_input_continuous:
  																		if not self.use_linear_projection:
  																									SCREAMING_SNAKE_CASE			: Union[str, Any]	     =hidden_states.reshape(snake_case_		,		snake_case_		,		snake_case_		,		snake_case_							).permute(0		,		3		,		1		,		2							).contiguous()
  																									SCREAMING_SNAKE_CASE			: Optional[Any]	     =self.proj_out(snake_case_							)
  																		else:
  																									SCREAMING_SNAKE_CASE			: Optional[int]	     =self.proj_out(snake_case_							)
  																									SCREAMING_SNAKE_CASE			: Optional[int]	     =hidden_states.reshape(snake_case_		,		snake_case_		,		snake_case_		,		snake_case_							).permute(0		,		3		,		1		,		2							).contiguous()
  
  																		SCREAMING_SNAKE_CASE			: Any	     =hidden_states + residual
  											elif self.is_input_vectorized:
  																		SCREAMING_SNAKE_CASE			: Optional[Any]	     =self.norm_out(snake_case_							)
  																		SCREAMING_SNAKE_CASE			: str	     =self.out(snake_case_							)
  																		# (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
  																		SCREAMING_SNAKE_CASE			: int	     =logits.permute(0		,		2		,		1							)
  
  																		# log(p(x_0))
  																		SCREAMING_SNAKE_CASE			: Union[str, Any]	     =F.log_softmax(logits.double()		,		dim=1							).float()
  											elif self.is_input_patches:
  																		# TODO: cleanup!
  																		SCREAMING_SNAKE_CASE			: List[Any]	     =self.transformer_blocks[0].norma.emb(
  																		    snake_case_		,		snake_case_		,		hidden_dtype=hidden_states.dtype							)
  																		SCREAMING_SNAKE_CASE     ,							SCREAMING_SNAKE_CASE			: str	     =self.proj_out_a(F.silu(snake_case_							)							).chunk(2		,		dim=1							)
  																		SCREAMING_SNAKE_CASE			: str	     =self.norm_out(snake_case_							) * (1 + scale[:, None]) + shift[:, None]
  																		SCREAMING_SNAKE_CASE			: Dict	     =self.proj_out_a(snake_case_							)
  
  																		# unpatchify
  																		SCREAMING_SNAKE_CASE			: Union[str, Any]	     =int(hidden_states.shape[1] ** 0.5							)
  																		SCREAMING_SNAKE_CASE			: List[str]	     =hidden_states.reshape(
  																		    shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)							)
  																		SCREAMING_SNAKE_CASE			: Any	     =torch.einsum('''nhwpqc->nchpwq'''		,		snake_case_							)
  																		SCREAMING_SNAKE_CASE			: Optional[int]	     =hidden_states.reshape(
  																		    shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size)							)
  
  											if not return_dict:
  																		return (output,)
  
  											return TransformeraDModelOutput(sample=snake_case_							)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  import sys
  
  sys.set_int_max_str_digits(0)  # type: ignore
  def 						lowerCAmelCase_       (	__a )       ->			bool:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: Optional[int]	     =[0] * 11
  							SCREAMING_SNAKE_CASE			: str	     =[0] * 11
  
  							# mark last 9 numbers
  							for _ in range(9 ):
  														SCREAMING_SNAKE_CASE			: List[str]	     =1
  														SCREAMING_SNAKE_CASE			: List[Any]	     =number // 10
  							# flag
  							SCREAMING_SNAKE_CASE			: str	     =True
  
  							# check last 9 numbers for pandigitality
  
  							for x in range(9 ):
  														if not check_last[x + 1]:
  																					SCREAMING_SNAKE_CASE			: Dict	     =False
  							if not f:
  														return f
  
  							# mark first 9 numbers
  							SCREAMING_SNAKE_CASE			: Dict	     =int(str(__a )[:9] )
  
  							for _ in range(9 ):
  														SCREAMING_SNAKE_CASE			: Union[str, Any]	     =1
  														SCREAMING_SNAKE_CASE			: Optional[int]	     =number // 10
  
  							# check first 9 numbers for pandigitality
  
  							for x in range(9 ):
  														if not check_front[x + 1]:
  																					SCREAMING_SNAKE_CASE			: Any	     =False
  							return f
  def 						lowerCAmelCase_       (	__a )       ->			bool:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: Any	     =[0] * 11
  
  							# mark last 9 numbers
  							for _ in range(9 ):
  														SCREAMING_SNAKE_CASE			: int	     =1
  														SCREAMING_SNAKE_CASE			: Optional[Any]	     =number // 10
  							# flag
  							SCREAMING_SNAKE_CASE			: Any	     =True
  
  							# check last 9 numbers for pandigitality
  
  							for x in range(9 ):
  														if not check_last[x + 1]:
  																					SCREAMING_SNAKE_CASE			: Any	     =False
  							return f
  def 						lowerCAmelCase_       (	)       ->			int:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: int	     =1
  							SCREAMING_SNAKE_CASE			: List[Any]	     =1
  							SCREAMING_SNAKE_CASE			: List[Any]	     =2
  							# temporary Fibonacci numbers
  
  							SCREAMING_SNAKE_CASE			: Dict	     =1
  							SCREAMING_SNAKE_CASE			: Dict	     =1
  							SCREAMING_SNAKE_CASE			: Tuple	     =2
  							# temporary Fibonacci numbers mod 1e9
  
  							# mod m=1e9, done for fast optimisation
  							SCREAMING_SNAKE_CASE			: str	     =[0] * 1000000
  							SCREAMING_SNAKE_CASE			: Any	     =1000000000
  
  							for x in range(1000000 ):
  														SCREAMING_SNAKE_CASE			: Optional[int]	     =(aa + ba) % m
  														SCREAMING_SNAKE_CASE			: int	     =ba % m
  														SCREAMING_SNAKE_CASE			: Optional[int]	     =ca % m
  														if checka(__a ):
  																					SCREAMING_SNAKE_CASE			: List[Any]	     =1
  
  							for x in range(1000000 ):
  														SCREAMING_SNAKE_CASE			: Tuple	     =a + b
  														SCREAMING_SNAKE_CASE			: Union[str, Any]	     =b
  														SCREAMING_SNAKE_CASE			: List[str]	     =c
  														# perform check only if in tocheck
  														if tocheck[x + 3] and check(__a ):
  																					return x + 3  # first 2 already done
  							return -1
  
  
  if __name__ == "__main__":
  							print(F'''{solution() = }''')
  
  
  
  
  
  
  