
'''simple docstring'''
import os

def     UpperCamelCase_  (						):
    """simple docstring"""






    snake_case_			:     Union[str, Any]        =    os.path.dirname(os.path.realpath(__SCREAMING_SNAKE_CASE							)							)
    snake_case_			:     Optional[int]        =    os.path.join(__SCREAMING_SNAKE_CASE,		"triangle.txt"							)

    with open(__SCREAMING_SNAKE_CASE							) as f:
        snake_case_			:     Dict        =    f.readlines()

    snake_case_			:     Tuple        =    [[int(__SCREAMING_SNAKE_CASE							) for y in x.rstrip("\r\n"							).split(" "							)] for x in triangle]

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


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






'''simple docstring'''
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


a_           =    logging.get_logger(__name__)

a_           =    {
    "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json",
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}






class  UpperCAmelCase_					(						snake_case__       ):
 UpperCAmelCase_		     =    """blenderbot"""
 UpperCAmelCase_		     =    ["""past_key_values"""]
 UpperCAmelCase_		     =    {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}





 def __init__(     self			,							lowercase_=80_08			,							lowercase_=1_28			,							lowercase_=2			,							lowercase_=1_02_40			,							lowercase_=32			,							lowercase_=24			,							lowercase_=1_02_40			,							lowercase_=32			,							lowercase_=0.0			,							lowercase_=0.0			,							lowercase_=True			,							lowercase_=True			,							lowercase_="gelu"			,							lowercase_=25_60			,							lowercase_=0.1			,							lowercase_=0.0			,							lowercase_=0.0			,							lowercase_=0.02			,							lowercase_=1			,							lowercase_=False			,							lowercase_=0			,							lowercase_=1			,							lowercase_=2			,							lowercase_=3			,							lowercase_=2			,							**lowercase_			,							):
     snake_case_			:     str        =    vocab_size
     snake_case_			:     str        =    max_position_embeddings
     snake_case_			:     Optional[Any]        =    d_model
     snake_case_			:     Any        =    encoder_ffn_dim
     snake_case_			:     Optional[Any]        =    encoder_layers
     snake_case_			:     List[Any]        =    encoder_attention_heads
     snake_case_			:     List[Any]        =    decoder_ffn_dim
     snake_case_			:     Optional[int]        =    decoder_layers
     snake_case_			:     Optional[int]        =    decoder_attention_heads
     snake_case_			:     Any        =    dropout
     snake_case_			:     List[str]        =    attention_dropout
     snake_case_			:     int        =    activation_dropout
     snake_case_			:     Dict        =    activation_function
     snake_case_			:     Any        =    init_std
     snake_case_			:     Union[str, Any]        =    encoder_layerdrop
     snake_case_			:     Optional[int]        =    decoder_layerdrop
     snake_case_			:     Any        =    use_cache
     snake_case_			:     List[str]        =    encoder_layers
     snake_case_			:     str        =    scale_embedding  # scale factor will be sqrt(d_model) if True

     super().__init__(
         pad_token_id=lowercase_			,							bos_token_id=lowercase_			,							eos_token_id=lowercase_			,							is_encoder_decoder=lowercase_			,							decoder_start_token_id=lowercase_			,							encoder_no_repeat_ngram_size=lowercase_			,							forced_eos_token_id=lowercase_			,							**lowercase_			,							)






class  UpperCAmelCase_					(						snake_case__       ):





 @property
 def 							snake_case__		(     self):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     int        =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ])
         if self.use_past:
             snake_case_			:     Any        =    {0: "batch"}
             snake_case_			:     Optional[int]        =    {0: "batch", 1: "past_decoder_sequence + sequence"}
         else:
             snake_case_			:     int        =    {0: "batch", 1: "decoder_sequence"}
             snake_case_			:     int        =    {0: "batch", 1: "decoder_sequence"}
         if self.use_past:
             self.fill_with_past_key_values_(lowercase_			,							direction="inputs")
     elif self.task == "causal-lm":
         snake_case_			:     Tuple        =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ])
         if self.use_past:
             snake_case_      ,			snake_case_			:     Any        =    self.num_layers
             for i in range(lowercase_):
                 snake_case_			:     Dict        =    {0: "batch", 2: "past_sequence + sequence"}
                 snake_case_			:     Dict        =    {0: "batch", 2: "past_sequence + sequence"}
     else:
         snake_case_			:     str        =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                 ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
                 ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
             ])

     return common_inputs





 @property
 # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
 def 							snake_case__		(     self):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     Optional[int]        =    super().outputs
     else:
         snake_case_			:     Dict        =    super(lowercase_			,							self).outputs
         if self.use_past:
             snake_case_      ,			snake_case_			:     Any        =    self.num_layers
             for i in range(lowercase_):
                 snake_case_			:     str        =    {0: "batch", 2: "past_sequence + sequence"}
                 snake_case_			:     int        =    {0: "batch", 2: "past_sequence + sequence"}
     return common_outputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     snake_case_			:     List[Any]        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)
     # Generate decoder inputs
     snake_case_			:     int        =    seq_length if not self.use_past else 1
     snake_case_			:     List[str]        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)
     snake_case_			:     str        =    {F'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
     snake_case_			:     Any        =    dict(**lowercase_			,							**lowercase_)

     if self.use_past:
         if not is_torch_available():
             raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
         else:
             import torch
         snake_case_      ,			snake_case_			:     int        =    common_inputs["input_ids"].shape
         snake_case_			:     str        =    common_inputs["decoder_input_ids"].shape[1]
         snake_case_      ,			snake_case_			:     Tuple        =    self.num_attention_heads
         snake_case_			:     str        =    (
             batch,
             num_encoder_attention_heads,
             encoder_seq_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         snake_case_			:     Dict        =    decoder_seq_length
         snake_case_			:     List[Any]        =    (
             batch,
             num_decoder_attention_heads,
             decoder_past_length,
             self._config.hidden_size // num_decoder_attention_heads,
         )
         snake_case_			:     Optional[Any]        =    torch.cat(
             [common_inputs["decoder_attention_mask"], torch.ones(lowercase_			,							lowercase_)]			,							dim=1)
         snake_case_			:     Tuple        =    []
         snake_case_      ,			snake_case_			:     Tuple        =    self.num_layers

         for _ in range(lowercase_):
             common_inputs["past_key_values"].append(
                 (
                     torch.zeros(lowercase_),
                     torch.zeros(lowercase_),
                     torch.zeros(lowercase_),
                     torch.zeros(lowercase_),
                 ))
     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     snake_case_			:     str        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)

     if self.use_past:
         if not is_torch_available():
             raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
         else:
             import torch
         snake_case_      ,			snake_case_			:     Optional[Any]        =    common_inputs["input_ids"].shape
         snake_case_			:     List[str]        =    seqlen
         snake_case_      ,			snake_case_			:     Optional[int]        =    self.num_layers
         snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.num_attention_heads
         snake_case_			:     Optional[int]        =    (
             batch,
             num_encoder_attention_heads,
             past_key_values_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         snake_case_			:     Dict        =    common_inputs["attention_mask"].dtype
         snake_case_			:     Optional[Any]        =    torch.cat(
             [common_inputs["attention_mask"], torch.ones(lowercase_			,							lowercase_			,							dtype=lowercase_)]			,							dim=1)
         snake_case_			:     Tuple        =    [
             (torch.zeros(lowercase_), torch.zeros(lowercase_)) for _ in range(lowercase_)
         ]
     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     # Copied from OnnxConfig.generate_dummy_inputs
     # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
     # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
     snake_case_			:     Any        =    compute_effective_axis_dimension(
         lowercase_			,							fixed_dimension=OnnxConfig.default_fixed_batch			,							num_token_to_add=0)

     # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
     snake_case_			:     Tuple        =    tokenizer.num_special_tokens_to_add(lowercase_)
     snake_case_			:     Tuple        =    compute_effective_axis_dimension(
         lowercase_			,							fixed_dimension=OnnxConfig.default_fixed_sequence			,							num_token_to_add=lowercase_)

     # Generate dummy inputs according to compute batch and sequence
     snake_case_			:     Optional[int]        =    [" ".join([tokenizer.unk_token]) * seq_length] * batch_size
     snake_case_			:     Tuple        =    dict(tokenizer(lowercase_			,							return_tensors=lowercase_))
     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     Optional[Any]        =    self._generate_dummy_inputs_for_default_and_seqaseq_lm(
             lowercase_			,							batch_size=lowercase_			,							seq_length=lowercase_			,							is_pair=lowercase_			,							framework=lowercase_)

     elif self.task == "causal-lm":
         snake_case_			:     Dict        =    self._generate_dummy_inputs_for_causal_lm(
             lowercase_			,							batch_size=lowercase_			,							seq_length=lowercase_			,							is_pair=lowercase_			,							framework=lowercase_)
     else:
         snake_case_			:     Dict        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             lowercase_			,							batch_size=lowercase_			,							seq_length=lowercase_			,							is_pair=lowercase_			,							framework=lowercase_)

     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     int        =    super()._flatten_past_key_values_(lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)
     else:
         snake_case_			:     List[Any]        =    super(lowercase_			,							self)._flatten_past_key_values_(
             lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_):
     if direction not in ["inputs", "outputs"]:
         raise ValueError(F'direction must either be "inputs" or "outputs", but {direction} was given')

     snake_case_			:     Union[str, Any]        =    "past_key_values" if direction == "inputs" else "present"
     snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.num_layers

     snake_case_			:     List[Any]        =    "past_encoder_sequence"
     snake_case_			:     str        =    "past_decoder_sequence" if direction == "inputs" else "past_decoder_sequence + sequence"

     for i in range(lowercase_):
         snake_case_			:     Union[str, Any]        =    {0: "batch", 2: decoder_sequence}
         snake_case_			:     str        =    {0: "batch", 2: decoder_sequence}
         snake_case_			:     Any        =    {0: "batch", 2: encoder_sequence}
         snake_case_			:     Dict        =    {0: "batch", 2: encoder_sequence}




