code: 
  
  
  
  from __future__ import annotations
  
  import os
  
  
  
  class        lowerCAmelCase_	:
         UpperCAmelCase__       :      Optional[int]       =						(
             "High card",
             "One pair",
             "Two pairs",
             "Three of a kind",
             "Straight",
             "Flush",
             "Full house",
             "Four of a kind",
             "Straight flush",
             "Royal flush",
         )
  
         UpperCAmelCase__       :      Any       =						(
             "",  # placeholder as tuples are zero-indexed
             "One",
             "Two",
             "Three",
             "Four",
             "Five",
             "Six",
             "Seven",
             "Eight",
             "Nine",
             "Ten",
             "Jack",
             "Queen",
             "King",
             "Ace",
         )
         def __init__(    self,    SCREAMING_SNAKE_CASE_ )  ->	None:
            if not isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
               UpperCamelCase					:						str					=			F"""Hand should be of type 'str': {hand!r}"""
               raise TypeError(SCREAMING_SNAKE_CASE_ )
            # split removes duplicate whitespaces so no need of strip
            if len(hand.split(' ' ) ) != 5:
               UpperCamelCase					:						Any					=			F"""Hand should contain only 5 cards: {hand!r}"""
               raise ValueError(SCREAMING_SNAKE_CASE_ )
            UpperCamelCase					:						Optional[Any]					=			hand
            UpperCamelCase					:						int					=			0
            UpperCamelCase					:						Union[str, Any]					=			0
            UpperCamelCase			,  UpperCamelCase					:						str					=			self._internal_state()
            UpperCamelCase					:						Tuple					=			self._get_hand_type()
            UpperCamelCase					:						Any					=			self._card_values[0]
         @property
         def       snake_case_ (    self )  ->	Optional[Any]:
            return self._hand
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	str:
            # Breaking the tie works on the following order of precedence:
            # 1. First pair (default 0)
            # 2. Second pair (default 0)
            # 3. Compare all cards in reverse order because they are sorted.
  
            # First pair and second pair will only be a non-zero value if the card
            # type is either from the following:
            # 21: Four of a kind
            # 20: Full house
            # 17: Three of a kind
            # 16: Two pairs
            # 15: One pair
            if self._hand_type > other._hand_type:
               return "Win"
            elif self._hand_type < other._hand_type:
               return "Loss"
            elif self._first_pair == other._first_pair:
               if self._second_pair == other._second_pair:
                  return self._compare_cards(SCREAMING_SNAKE_CASE_ )
               else:
                  return "Win" if self._second_pair > other._second_pair else "Loss"
            return "Win" if self._first_pair > other._first_pair else "Loss"
         def       snake_case_ (    self )  ->	str:
            UpperCamelCase					:						str					=			PokerHand._HAND_NAME[self._hand_type - 14]
            UpperCamelCase					:						Union[str, Any]					=			PokerHand._CARD_NAME[self._high_card]
            UpperCamelCase					:						str					=			PokerHand._CARD_NAME[self._first_pair]
            UpperCamelCase					:						Dict					=			PokerHand._CARD_NAME[self._second_pair]
            if self._hand_type in [22, 19, 18]:
               return name + F""", {high}-high"""
            elif self._hand_type in [21, 17, 15]:
               return name + F""", {paira}s"""
            elif self._hand_type in [20, 16]:
               UpperCamelCase					:						Union[str, Any]					=			'over' if self._hand_type == 20 else 'and'
               return name + F""", {paira}s {join} {paira}s"""
            elif self._hand_type == 23:
               return name
            else:
               return name + F""", {high}"""
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	str:
            # Enumerate gives us the index as well as the element of a list
            for index, card_value in enumerate(self._card_values ):
               if card_value != other._card_values[index]:
                  return "Win" if card_value > other._card_values[index] else "Loss"
            return "Tie"
         def       snake_case_ (    self )  ->	int:
            # Number representing the type of hand internally:
            # 23: Royal flush
            # 22: Straight flush
            # 21: Four of a kind
            # 20: Full house
            # 19: Flush
            # 18: Straight
            # 17: Three of a kind
            # 16: Two pairs
            # 15: One pair
            # 14: High card
            if self._is_flush():
               if self._is_five_high_straight() or self._is_straight():
                  return 23 if sum(self._card_values ) == 60 else 22
               return 19
            elif self._is_five_high_straight() or self._is_straight():
               return 18
            return 14 + self._is_same_kind()
         def       snake_case_ (    self )  ->	bool:
            return len(self._card_suit ) == 1
         def       snake_case_ (    self )  ->	bool:
            # If a card is a five high straight (low ace) change the location of
            # ace from the start of the list to the end. Check whether the first
            # element is ace or not. (Don't want to change again)
            # Five high straight (low ace): AH 2H 3S 4C 5D
            # Why use sorted here? One call to this function will mutate the list to
            # [5, 4, 3, 2, 14] and so for subsequent calls (which will be rare) we
            # need to compare the sorted version.
            # Refer test_multiple_calls_five_high_straight in test_poker_hand.py
            if sorted(self._card_values ) == [2, 3, 4, 5, 14]:
               if self._card_values[0] == 14:
                  # Remember, our list is sorted in reverse order
                  UpperCamelCase					:						Optional[Any]					=			self._card_values.pop(0 )
                  self._card_values.append(SCREAMING_SNAKE_CASE_ )
               return True
            return False
         def       snake_case_ (    self )  ->	bool:
            for i in range(4 ):
               if self._card_values[i] - self._card_values[i + 1] != 1:
                  return False
            return True
         def       snake_case_ (    self )  ->	int:
            # Kind Values for internal use:
            # 7: Four of a kind
            # 6: Full house
            # 3: Three of a kind
            # 2: Two pairs
            # 1: One pair
            # 0: False
            UpperCamelCase					:						List[Any]					=			0
            for i in range(4 ):
               # Compare two cards at a time, if they are same increase 'kind',
               # add the value of the card to val1, if it is repeating again we
               # will add 2 to 'kind' as there are now 3 cards with same value.
               # If we get card of different value than val1, we will do the same
               # thing with val2
               if self._card_values[i] == self._card_values[i + 1]:
                  if not vala:
                     UpperCamelCase					:						List[Any]					=			self._card_values[i]
                     kind += 1
                  elif vala == self._card_values[i]:
                     kind += 2
                  elif not vala:
                     UpperCamelCase					:						int					=			self._card_values[i]
                     kind += 1
                  elif vala == self._card_values[i]:
                     kind += 2
          # For consistency in hand type (look at note in _get_hand_type function)
            UpperCamelCase					:						Optional[Any]					=			kind + 2 if kind in [4, 5] else kind
            # first meaning first pair to compare in 'compare_with'
            UpperCamelCase					:						str					=			max(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
            UpperCamelCase					:						Optional[Any]					=			min(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
            # If it's full house (three count pair + two count pair), make sure
            # first pair is three count and if not then switch them both.
            if kind == 6 and self._card_values.count(SCREAMING_SNAKE_CASE_ ) != 3:
               UpperCamelCase			,  UpperCamelCase					:						int					=			second, first
            UpperCamelCase					:						Optional[Any]					=			first
            UpperCamelCase					:						Union[str, Any]					=			second
            return kind
         def       snake_case_ (    self )  ->	tuple[list[int], set[str]]:
            # Internal representation of hand as a list of card values and
            # a set of card suit
            UpperCamelCase					:						dict					=			{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
            UpperCamelCase					:						int					=			self._hand.translate(str.maketrans(SCREAMING_SNAKE_CASE_ ) ).split()
            UpperCamelCase					:						Dict					=			[int(card[:-1] ) for card in new_hand]
            UpperCamelCase					:						Dict					=			{card[-1] for card in new_hand}
            return sorted(SCREAMING_SNAKE_CASE_,    reverse=SCREAMING_SNAKE_CASE_ ), card_suit
         def __repr__(    self )  ->	Dict:
            return F"""{self.__class__}(\"{self._hand}\")"""
         def __str__(    self )  ->	int:
            return self._hand
         def __eq__(    self,    SCREAMING_SNAKE_CASE_ )  ->	str:
            if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
               return self.compare_with(SCREAMING_SNAKE_CASE_ ) == "Tie"
            return NotImplemented
         def __lt__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Optional[int]:
            if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
               return self.compare_with(SCREAMING_SNAKE_CASE_ ) == "Loss"
            return NotImplemented
         def __le__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Union[str, Any]:
            if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
               return self < other or self == other
            return NotImplemented
         def __gt__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Tuple:
            if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
               return not self < other and self != other
            return NotImplemented
         def __ge__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Any:
            if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
               return not self < other
            return NotImplemented
  
  
  
  
  
  
         def __hash__(    self )  ->	Union[str, Any]:
            return object.__hash__(self )
  
  
  
  
  
  
  def 	UpperCamelCase			(     )			->  int:
     # Solution for problem number 54 from Project Euler
     # Input from poker_hands.txt file
     UpperCamelCase					:						str					=			0
     UpperCamelCase					:						Tuple					=			os.path.abspath(os.path.dirname(snake_case__			)			)
     UpperCamelCase					:						Union[str, Any]					=			os.path.join(snake_case__ ,  'poker_hands.txt'			)
     with open(snake_case__			) as file_hand:
        for line in file_hand:
           UpperCamelCase					:						Tuple					=			line[:14].strip()
           UpperCamelCase					:						Union[str, Any]					=			line[15:].strip()
           UpperCamelCase			,  UpperCamelCase					:						Any					=			PokerHand(snake_case__			), PokerHand(snake_case__			)
           UpperCamelCase					:						Union[str, Any]					=			player.compare_with(snake_case__			)
           if output == "Win":
              answer += 1
     return answer
  
  
  if __name__ == "__main__":
      solution()
  
  
  
  
style_context: 
  
  
  
  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_	(						a__							):
         UpperCAmelCase__       :      torch.FloatTensor
  
  
  
  
  
  
  class        lowerCAmelCase_	(						a__ ,					a__							):
         @register_to_config
         def __init__(    self,    SCREAMING_SNAKE_CASE_ = 16,    SCREAMING_SNAKE_CASE_ = 88,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = 1,    SCREAMING_SNAKE_CASE_ = 0.0,    SCREAMING_SNAKE_CASE_ = 32,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = False,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = "geglu",    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = False,    SCREAMING_SNAKE_CASE_ = False,    SCREAMING_SNAKE_CASE_ = False,    SCREAMING_SNAKE_CASE_ = "layer_norm",    SCREAMING_SNAKE_CASE_ = True,    )  ->	Union[str, Any]:
            super().__init__()
            UpperCamelCase					:						Tuple					=			use_linear_projection
            UpperCamelCase					:						int					=			num_attention_heads
            UpperCamelCase					:						Dict					=			attention_head_dim
            UpperCamelCase					:						Optional[int]					=			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
            UpperCamelCase					:						Optional[Any]					=			(in_channels is not None) and (patch_size is None)
            UpperCamelCase					:						Tuple					=			num_vector_embeds is not None
            UpperCamelCase					:						Optional[int]					=			in_channels is not None and patch_size is not None
  
            if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
               UpperCamelCase					:						Any					=			(
                   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',    SCREAMING_SNAKE_CASE_,    standard_warn=SCREAMING_SNAKE_CASE_ )
               UpperCamelCase					:						Any					=			'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:
               UpperCamelCase					:						Optional[int]					=			in_channels
  
               UpperCamelCase					:						str					=			torch.nn.GroupNorm(num_groups=SCREAMING_SNAKE_CASE_,    num_channels=SCREAMING_SNAKE_CASE_,    eps=1e-6,    affine=SCREAMING_SNAKE_CASE_ )
               if use_linear_projection:
                  UpperCamelCase					:						Dict					=			nn.Linear(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
               else:
                  UpperCamelCase					:						Any					=			nn.Convad(SCREAMING_SNAKE_CASE_,    SCREAMING_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"
  
               UpperCamelCase					:						Union[str, Any]					=			sample_size
               UpperCamelCase					:						int					=			sample_size
               UpperCamelCase					:						Optional[Any]					=			num_vector_embeds
               UpperCamelCase					:						str					=			self.height * self.width
  
               UpperCamelCase					:						Union[str, Any]					=			ImagePositionalEmbeddings(
                   num_embed=SCREAMING_SNAKE_CASE_,    embed_dim=SCREAMING_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"
  
               UpperCamelCase					:						int					=			sample_size
               UpperCamelCase					:						Optional[Any]					=			sample_size
  
               UpperCamelCase					:						List[str]					=			patch_size
               UpperCamelCase					:						Tuple					=			PatchEmbed(
                   height=SCREAMING_SNAKE_CASE_,    width=SCREAMING_SNAKE_CASE_,    patch_size=SCREAMING_SNAKE_CASE_,    in_channels=SCREAMING_SNAKE_CASE_,    embed_dim=SCREAMING_SNAKE_CASE_,    )
  
            # 3. Define transformers blocks
            UpperCamelCase					:						Any					=			nn.ModuleList(
                [
                    BasicTransformerBlock(
                        SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    dropout=SCREAMING_SNAKE_CASE_,    cross_attention_dim=SCREAMING_SNAKE_CASE_,    activation_fn=SCREAMING_SNAKE_CASE_,    num_embeds_ada_norm=SCREAMING_SNAKE_CASE_,    attention_bias=SCREAMING_SNAKE_CASE_,    only_cross_attention=SCREAMING_SNAKE_CASE_,    upcast_attention=SCREAMING_SNAKE_CASE_,    norm_type=SCREAMING_SNAKE_CASE_,    norm_elementwise_affine=SCREAMING_SNAKE_CASE_,    )
                    for d in range(SCREAMING_SNAKE_CASE_ )
                ] )
  
            # 4. Define output layers
            UpperCamelCase					:						Optional[int]					=			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:
                  UpperCamelCase					:						Optional[Any]					=			nn.Linear(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
               else:
                  UpperCamelCase					:						List[str]					=			nn.Convad(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    kernel_size=1,    stride=1,    padding=0 )
            elif self.is_input_vectorized:
               UpperCamelCase					:						Optional[Any]					=			nn.LayerNorm(SCREAMING_SNAKE_CASE_ )
               UpperCamelCase					:						Any					=			nn.Linear(SCREAMING_SNAKE_CASE_,    self.num_vector_embeds - 1 )
            elif self.is_input_patches:
               UpperCamelCase					:						List[str]					=			nn.LayerNorm(SCREAMING_SNAKE_CASE_,    elementwise_affine=SCREAMING_SNAKE_CASE_,    eps=1e-6 )
               UpperCamelCase					:						Tuple					=			nn.Linear(SCREAMING_SNAKE_CASE_,    2 * inner_dim )
               UpperCamelCase					:						Any					=			nn.Linear(SCREAMING_SNAKE_CASE_,    patch_size * patch_size * self.out_channels )
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = True,    )  ->	Optional[Any]:
            # 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)
               UpperCamelCase					:						List[str]					=			(1 - attention_mask.to(hidden_states.dtype )) * -1_00_00.0
               UpperCamelCase					:						Tuple					=			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:
               UpperCamelCase					:						int					=			(1 - encoder_attention_mask.to(hidden_states.dtype )) * -1_00_00.0
               UpperCamelCase					:						Dict					=			encoder_attention_mask.unsqueeze(1 )
  
            # 1. Input
            if self.is_input_continuous:
               UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			hidden_states.shape
               UpperCamelCase					:						str					=			hidden_states
  
               UpperCamelCase					:						Union[str, Any]					=			self.norm(SCREAMING_SNAKE_CASE_ )
               if not self.use_linear_projection:
                  UpperCamelCase					:						Tuple					=			self.proj_in(SCREAMING_SNAKE_CASE_ )
                  UpperCamelCase					:						Optional[int]					=			hidden_states.shape[1]
                  UpperCamelCase					:						Tuple					=			hidden_states.permute(0,    2,    3,    1 ).reshape(SCREAMING_SNAKE_CASE_,    height * width,    SCREAMING_SNAKE_CASE_ )
               else:
                  UpperCamelCase					:						Optional[int]					=			hidden_states.shape[1]
                  UpperCamelCase					:						Dict					=			hidden_states.permute(0,    2,    3,    1 ).reshape(SCREAMING_SNAKE_CASE_,    height * width,    SCREAMING_SNAKE_CASE_ )
                  UpperCamelCase					:						Union[str, Any]					=			self.proj_in(SCREAMING_SNAKE_CASE_ )
            elif self.is_input_vectorized:
               UpperCamelCase					:						Union[str, Any]					=			self.latent_image_embedding(SCREAMING_SNAKE_CASE_ )
            elif self.is_input_patches:
               UpperCamelCase					:						Any					=			self.pos_embed(SCREAMING_SNAKE_CASE_ )
  
            # 2. Blocks
            for block in self.transformer_blocks:
               UpperCamelCase					:						Optional[int]					=			block(
                   SCREAMING_SNAKE_CASE_,    attention_mask=SCREAMING_SNAKE_CASE_,    encoder_hidden_states=SCREAMING_SNAKE_CASE_,    encoder_attention_mask=SCREAMING_SNAKE_CASE_,    timestep=SCREAMING_SNAKE_CASE_,    cross_attention_kwargs=SCREAMING_SNAKE_CASE_,    class_labels=SCREAMING_SNAKE_CASE_,    )
  
            # 3. Output
            if self.is_input_continuous:
               if not self.use_linear_projection:
                  UpperCamelCase					:						Tuple					=			hidden_states.reshape(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ).permute(0,    3,    1,    2 ).contiguous()
                  UpperCamelCase					:						int					=			self.proj_out(SCREAMING_SNAKE_CASE_ )
               else:
                  UpperCamelCase					:						Optional[int]					=			self.proj_out(SCREAMING_SNAKE_CASE_ )
                  UpperCamelCase					:						Optional[int]					=			hidden_states.reshape(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ).permute(0,    3,    1,    2 ).contiguous()
  
               UpperCamelCase					:						Any					=			hidden_states + residual
            elif self.is_input_vectorized:
               UpperCamelCase					:						List[Any]					=			self.norm_out(SCREAMING_SNAKE_CASE_ )
               UpperCamelCase					:						Optional[int]					=			self.out(SCREAMING_SNAKE_CASE_ )
               # (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
               UpperCamelCase					:						Tuple					=			logits.permute(0,    2,    1 )
  
               # log(p(x_0))
               UpperCamelCase					:						List[str]					=			F.log_softmax(logits.double(),    dim=1 ).float()
            elif self.is_input_patches:
               # TODO: cleanup!
               UpperCamelCase					:						int					=			self.transformer_blocks[0].norma.emb(
                   SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    hidden_dtype=hidden_states.dtype )
               UpperCamelCase			,  UpperCamelCase					:						int					=			self.proj_out_a(F.silu(SCREAMING_SNAKE_CASE_ ) ).chunk(2,    dim=1 )
               UpperCamelCase					:						Dict					=			self.norm_out(SCREAMING_SNAKE_CASE_ ) * (1 + scale[:, None]) + shift[:, None]
               UpperCamelCase					:						Any					=			self.proj_out_a(SCREAMING_SNAKE_CASE_ )
  
               # unpatchify
               UpperCamelCase					:						Union[str, Any]					=			int(hidden_states.shape[1] ** 0.5 )
               UpperCamelCase					:						Tuple					=			hidden_states.reshape(
                   shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels) )
               UpperCamelCase					:						int					=			torch.einsum('nhwpqc->nchpwq',    SCREAMING_SNAKE_CASE_ )
               UpperCamelCase					:						Any					=			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=SCREAMING_SNAKE_CASE_ )
  
  
  
  