





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  __A   (   lowerCAmelCase			):

			'''simple docstring'''







			lowerCAmelCase_												=						42






class  __A   (   lowerCAmelCase      ,    lowerCAmelCase			):

			'''simple docstring'''







			@register_to_config
			def __init__(   self	,  __lowerCAmelCase = 1_6	,  __lowerCAmelCase = 8_8	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = 1	,  __lowerCAmelCase = 0.0	,  __lowerCAmelCase = 3_2	,  __lowerCAmelCase = None	,  __lowerCAmelCase = False	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = "geglu"	,  __lowerCAmelCase = None	,  __lowerCAmelCase = False	,  __lowerCAmelCase = False	,  __lowerCAmelCase = False	,  __lowerCAmelCase = "layer_norm"	,  __lowerCAmelCase = True	,  ):



				'''simple docstring'''







				super().__init__()
				lowerCamelCase__        =		use_linear_projection
				lowerCamelCase__        =		num_attention_heads
				lowerCamelCase__        =		attention_head_dim
				lowerCamelCase__        =		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
				lowerCamelCase__        =		(in_channels is not None) and (patch_size is None)
				lowerCamelCase__        =		num_vector_embeds is not None
				lowerCamelCase__        =		in_channels is not None and patch_size is not None

				if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
					lowerCamelCase__        =		(
					    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'''	,  __lowerCAmelCase	,  standard_warn=__lowerCAmelCase							)
					lowerCamelCase__        =		'''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:
					lowerCamelCase__        =		in_channels

					lowerCamelCase__        =		torch.nn.GroupNorm(num_groups=__lowerCAmelCase	,  num_channels=__lowerCAmelCase	,  eps=1E-6	,  affine=__lowerCAmelCase							)
					if use_linear_projection:
						lowerCamelCase__        =		nn.Linear(__lowerCAmelCase	,  __lowerCAmelCase							)
					else:
						lowerCamelCase__        =		nn.Convad(__lowerCAmelCase	,  __lowerCAmelCase	,  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"

					lowerCamelCase__        =		sample_size
					lowerCamelCase__        =		sample_size
					lowerCamelCase__        =		num_vector_embeds
					lowerCamelCase__        =		self.height * self.width

					lowerCamelCase__        =		ImagePositionalEmbeddings(
					    num_embed=__lowerCAmelCase	,  embed_dim=__lowerCAmelCase	,  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"

					lowerCamelCase__        =		sample_size
					lowerCamelCase__        =		sample_size

					lowerCamelCase__        =		patch_size
					lowerCamelCase__        =		PatchEmbed(
					    height=__lowerCAmelCase	,  width=__lowerCAmelCase	,  patch_size=__lowerCAmelCase	,  in_channels=__lowerCAmelCase	,  embed_dim=__lowerCAmelCase	,  )

				# 3. Define transformers blocks
				lowerCamelCase__        =		nn.ModuleList(
				    [
				        BasicTransformerBlock(
				            __lowerCAmelCase	,  __lowerCAmelCase	,  __lowerCAmelCase	,  dropout=__lowerCAmelCase	,  cross_attention_dim=__lowerCAmelCase	,  activation_fn=__lowerCAmelCase	,  num_embeds_ada_norm=__lowerCAmelCase	,  attention_bias=__lowerCAmelCase	,  only_cross_attention=__lowerCAmelCase	,  upcast_attention=__lowerCAmelCase	,  norm_type=__lowerCAmelCase	,  norm_elementwise_affine=__lowerCAmelCase	,  )
				        for d in range(__lowerCAmelCase							)
				    ]							)

				# 4. Define output layers
				lowerCamelCase__        =		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:
						lowerCamelCase__        =		nn.Linear(__lowerCAmelCase	,  __lowerCAmelCase							)
					else:
						lowerCamelCase__        =		nn.Convad(__lowerCAmelCase	,  __lowerCAmelCase	,  kernel_size=1	,  stride=1	,  padding=0							)
				elif self.is_input_vectorized:
					lowerCamelCase__        =		nn.LayerNorm(__lowerCAmelCase							)
					lowerCamelCase__        =		nn.Linear(__lowerCAmelCase	,  self.num_vector_embeds - 1							)
				elif self.is_input_patches:
					lowerCamelCase__        =		nn.LayerNorm(__lowerCAmelCase	,  elementwise_affine=__lowerCAmelCase	,  eps=1E-6							)
					lowerCamelCase__        =		nn.Linear(__lowerCAmelCase	,  2 * inner_dim							)
					lowerCamelCase__        =		nn.Linear(__lowerCAmelCase	,  patch_size * patch_size * self.out_channels							)





			def 		__lowerCamelCase    (   self	,  __lowerCAmelCase	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = None	,  __lowerCAmelCase = True	,  ):



				'''simple docstring'''







				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)
					lowerCamelCase__        =		(1 - attention_mask.to(hidden_states.dtype							)) * -1_0000.0
					lowerCamelCase__        =		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:
					lowerCamelCase__        =		(1 - encoder_attention_mask.to(hidden_states.dtype							)) * -1_0000.0
					lowerCamelCase__        =		encoder_attention_mask.unsqueeze(1							)

				# 1. Input
				if self.is_input_continuous:
					lowerCamelCase__    ,     lowerCamelCase__    ,     lowerCamelCase__    ,     lowerCamelCase__        =		hidden_states.shape
					lowerCamelCase__        =		hidden_states

					lowerCamelCase__        =		self.norm(__lowerCAmelCase							)
					if not self.use_linear_projection:
						lowerCamelCase__        =		self.proj_in(__lowerCAmelCase							)
						lowerCamelCase__        =		hidden_states.shape[1]
						lowerCamelCase__        =		hidden_states.permute(0	,  2	,  3	,  1							).reshape(__lowerCAmelCase	,  height * width	,  __lowerCAmelCase							)
					else:
						lowerCamelCase__        =		hidden_states.shape[1]
						lowerCamelCase__        =		hidden_states.permute(0	,  2	,  3	,  1							).reshape(__lowerCAmelCase	,  height * width	,  __lowerCAmelCase							)
						lowerCamelCase__        =		self.proj_in(__lowerCAmelCase							)
				elif self.is_input_vectorized:
					lowerCamelCase__        =		self.latent_image_embedding(__lowerCAmelCase							)
				elif self.is_input_patches:
					lowerCamelCase__        =		self.pos_embed(__lowerCAmelCase							)

				# 2. Blocks
				for block in self.transformer_blocks:
					lowerCamelCase__        =		block(
					    __lowerCAmelCase	,  attention_mask=__lowerCAmelCase	,  encoder_hidden_states=__lowerCAmelCase	,  encoder_attention_mask=__lowerCAmelCase	,  timestep=__lowerCAmelCase	,  cross_attention_kwargs=__lowerCAmelCase	,  class_labels=__lowerCAmelCase	,  )

				# 3. Output
				if self.is_input_continuous:
					if not self.use_linear_projection:
						lowerCamelCase__        =		hidden_states.reshape(__lowerCAmelCase	,  __lowerCAmelCase	,  __lowerCAmelCase	,  __lowerCAmelCase							).permute(0	,  3	,  1	,  2							).contiguous()
						lowerCamelCase__        =		self.proj_out(__lowerCAmelCase							)
					else:
						lowerCamelCase__        =		self.proj_out(__lowerCAmelCase							)
						lowerCamelCase__        =		hidden_states.reshape(__lowerCAmelCase	,  __lowerCAmelCase	,  __lowerCAmelCase	,  __lowerCAmelCase							).permute(0	,  3	,  1	,  2							).contiguous()

					lowerCamelCase__        =		hidden_states + residual
				elif self.is_input_vectorized:
					lowerCamelCase__        =		self.norm_out(__lowerCAmelCase							)
					lowerCamelCase__        =		self.out(__lowerCAmelCase							)
					# (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
					lowerCamelCase__        =		logits.permute(0	,  2	,  1							)

					# log(p(x_0))
					lowerCamelCase__        =		F.log_softmax(logits.double()	,  dim=1							).float()
				elif self.is_input_patches:
					# TODO: cleanup!
					lowerCamelCase__        =		self.transformer_blocks[0].norma.emb(
					    __lowerCAmelCase	,  __lowerCAmelCase	,  hidden_dtype=hidden_states.dtype							)
					lowerCamelCase__    ,     lowerCamelCase__        =		self.proj_out_a(F.silu(__lowerCAmelCase							)							).chunk(2	,  dim=1							)
					lowerCamelCase__        =		self.norm_out(__lowerCAmelCase							) * (1 + scale[:, None]) + shift[:, None]
					lowerCamelCase__        =		self.proj_out_a(__lowerCAmelCase							)

					# unpatchify
					lowerCamelCase__        =		lowerCamelCase__        =		int(hidden_states.shape[1] ** 0.5							)
					lowerCamelCase__        =		hidden_states.reshape(
					    shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)							)
					lowerCamelCase__        =		torch.einsum('''nhwpqc->nchpwq'''	,  __lowerCAmelCase							)
					lowerCamelCase__        =		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=__lowerCAmelCase							)










import os





def lowerCAmelCase__()    ->				Optional[Any]:







	'''simple docstring'''







	lowerCamelCase__        =		os.path.dirname(os.path.realpath(__snake_case							)							)
	lowerCamelCase__        =		os.path.join(__snake_case	,'''triangle.txt'''							)

	with open(__snake_case							) as f:
		lowerCamelCase__        =		f.readlines()

	lowerCamelCase__        =		[[int(__snake_case							) for y in x.rstrip('''\r\n'''							).split(''' '''							)] for x in triangle]

	for i in range(1	,len(__snake_case							)							):
		for j in range(len(a[i]							)							):
			lowerCamelCase__        =		a[i - 1][j] if j != len(a[i - 1]							) else 0
			lowerCamelCase__        =		a[i - 1][j - 1] if j > 0 else 0
			a[i][j] += max(__snake_case	,__snake_case							)
	return max(a[-1]							)


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



