"""simple docstring"""





from statistics import mean

import numpy as np


def    lowercase_   (   _lowerCamelCase:	list						,   _lowerCamelCase:	list						,   _lowerCamelCase:	list						,   _lowerCamelCase:	int      ) ->      list:



							'''simple docstring'''

							__lowerCamelCase					:		Tuple		   =     0
							# Number of processes finished
							__lowerCamelCase					:		Any		   =     0
							# Displays the finished process.
							# If it is 0, the performance is completed if it is 1, before the performance.
							__lowerCamelCase					:		Dict		   =     [0] * no_of_process
							# List to include calculation results
							__lowerCamelCase					:		Optional[int]		   =     [0] * no_of_process

							# Sort by arrival time.
							__lowerCamelCase					:		int		   =     [burst_time[i] for i in np.argsort(_lowerCamelCase      )]
							__lowerCamelCase					:		Optional[Any]		   =     [process_name[i] for i in np.argsort(_lowerCamelCase      )]
							arrival_time.sort()

							while no_of_process > finished_process_count:
														__lowerCamelCase					:		List[str]		   =     0
														while finished_process[i] == 1:
																					i += 1
														if current_time < arrival_time[i]:
																					__lowerCamelCase					:		Optional[int]		   =     arrival_time[i]

														__lowerCamelCase					:		Union[str, Any]		   =     0
														# Index showing the location of the process being performed
														__lowerCamelCase					:		List[Any]		   =     0
														# Saves the current response ratio.
														__lowerCamelCase					:		List[Any]		   =     0
														for i in range(0						,   _lowerCamelCase      ):
																					if finished_process[i] == 0 and arrival_time[i] <= current_time:
																												__lowerCamelCase					:		List[str]		   =     (burst_time[i] + (current_time - arrival_time[i])) / burst_time[
																												    i
																												]
																					if response_ratio < temp:
																												__lowerCamelCase					:		Any		   =     temp
																												__lowerCamelCase					:		Optional[int]		   =     i

        # Calculate the turn around time
														__lowerCamelCase					:		Optional[Any]		   =     current_time + burst_time[loc] - arrival_time[loc]
														current_time += burst_time[loc]
														# Indicates that the process has been performed.
														__lowerCamelCase					:		Optional[int]		   =     1
														# Increase finished_process_count by 1
														finished_process_count += 1

							return turn_around_time


def    lowercase_   (   _lowerCamelCase:	list						,   _lowerCamelCase:	list						,   _lowerCamelCase:	list						,   _lowerCamelCase:	int      ) ->      list:



							'''simple docstring'''

							__lowerCamelCase					:		Dict		   =     [0] * no_of_process
							for i in range(0						,   _lowerCamelCase      ):
														__lowerCamelCase					:		List[str]		   =     turn_around_time[i] - burst_time[i]
							return waiting_time


if __name__ == "__main__":
				__A  =				5
				__A  =				['''A''', '''B''', '''C''', '''D''', '''E''']
				__A  =				[1, 2, 3, 4, 5]
				__A  =				[1, 2, 3, 4, 5]

				__A  =				calculate_turn_around_time(
				    process_name, arrival_time, burst_time, no_of_process
				)
				__A  =				calculate_waiting_time(
				    process_name, turn_around_time, burst_time, no_of_process
				)

				print('''Process name \tArrival time \tBurst time \tTurn around time \tWaiting time''')
				for i in range(0, no_of_process):
								print(
								    F"""{process_name[i]}\t\t{arrival_time[i]}\t\t{burst_time[i]}\t\t"""
								    F"""{turn_around_time[i]}\t\t\t{waiting_time[i]}"""
								)

				print(F"""average waiting time : {mean(waiting_time):.5f}""")
				print(F"""average turn around time : {mean(turn_around_time):.5f}""")
"""simple docstring"""





import os


def    lowercase_   (   ) ->      List[str]:



							'''simple docstring'''

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

							with open(_lowerCamelCase      ) as f:
														__lowerCamelCase					:		List[str]		   =     f.readlines()

							__lowerCamelCase					:		List[str]		   =     []
							for line in triangle:
														__lowerCamelCase					:		Optional[int]		   =     []
														for number in line.strip().split(" "      ):
																					numbers_from_line.append(int(_lowerCamelCase      )      )
														a.append(_lowerCamelCase      )

							for i in range(1						,   len(_lowerCamelCase      )      ):
														for j in range(len(a[i]      )      ):
																					__lowerCamelCase					:		int		   =     a[i - 1][j] if j != len(a[i - 1]      ) else 0
																					__lowerCamelCase					:		Union[str, Any]		   =     a[i - 1][j - 1] if j > 0 else 0
																					a[i][j] += max(_lowerCamelCase						,   _lowerCamelCase      )
							return max(a[-1]      )


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