code: 
  
  
  """simple docstring"""
  
  
  
  
  import os
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			os.path.dirname(os.path.realpath(lowercase__    )    )
  			__lowerCamelCase        =			os.path.join(lowercase__, """triangle.txt"""    )
  
  			with open(lowercase__    ) as in_file:
  						__lowerCamelCase        =			[[int(lowercase__    ) for i in line.split()] for line in in_file]
  
  			while len(lowercase__    ) != 1:
  						__lowerCamelCase        =			triangle.pop()
  						__lowerCamelCase        =			triangle[-1]
  						for j in range(len(lowercase__    ) - 1    ):
  									curr_row[j] += max(last_row[j], last_row[j + 1]    )
  			return triangle[0][0]
  
  
  if __name__ == "__main__":
  					print(solution())
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  # Lint as: python3
  
  import hashlib
  from typing import Union
  
  
  
  
  
  def 			a_   (  lowercase__   :Union[str, int, bytes]    ):
  			if isinstance(lowercase__, lowercase__    ):
  						# Data already in bytes, returns as it as
  						return hash_data
  			elif isinstance(lowercase__, lowercase__    ):
  						# We keep the data as it as for it ot be later encoded to UTF-8
  						# However replace `\\` with `/` for Windows compatibility
  						__lowerCamelCase        =			hash_data.replace("""\\""", """/"""    )
  			elif isinstance(lowercase__, lowercase__    ):
  						__lowerCamelCase        =			str(lowercase__    )
  			else:
  						# If data is not of the required type, raise error
  						raise InvalidKeyError(lowercase__    )
  
  			return hash_data.encode("""utf-8"""    )
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  
  
  
  
  							def __init__(    self:						Union[str, Any]    ,       A_:						Tuple      ):
  										__lowerCamelCase        =			"""\nFAILURE TO GENERATE DATASET: Invalid key type detected"""
  										__lowerCamelCase        =			f'\nFound Key {hash_data} of type {type(A_      )}'
  										__lowerCamelCase        =			"""\nKeys should be either str, int or bytes type"""
  										super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'      )
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  
  
  
  
  							def __init__(    self:						Any    ,       A_:						Dict    ,       A_:						List[Any]    ,       A_:						List[str]=""      ):
  										__lowerCamelCase        =			key
  										__lowerCamelCase        =			duplicate_key_indices
  										__lowerCamelCase        =			fix_msg
  										__lowerCamelCase        =			"""Found multiple examples generated with the same key"""
  										if len(A_      ) <= 20:
  													__lowerCamelCase        =			f'\nThe examples at index {", ".join(A_      )} have the key {key}'
  										else:
  													__lowerCamelCase        =			f'\nThe examples at index {", ".join(duplicate_key_indices[:20]      )}... ({len(A_      ) - 20} more) have the key {key}'
  										__lowerCamelCase        =			"""\n""" + fix_msg if fix_msg else """"""
  										super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'      )
  
  
  
  
  class  __snake_case      :
  
  
  
  
  							def __init__(    self:						Dict    ,       A_:						str      ):
  										__lowerCamelCase        =			hashlib.mda(_as_bytes(A_      )      )
  
  
  
  
  							def      __a      (    self:						int    ,       A_:						Union[str, int, bytes]      ):
  										__lowerCamelCase        =			self._split_mda.copy()
  										__lowerCamelCase        =			_as_bytes(A_      )
  										mda.update(A_      )
  										# Convert to integer with hexadecimal conversion
  										return int(mda.hexdigest()    ,       16      )
  
  
  
  
  