






import io
import itertools
import json
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa
import pyarrow.json as paj

import datasets
from datasets.table import table_cast
from datasets.utils.file_utils import readline


lowerCamelCase__							=     datasets.utils.logging.get_logger(__name__)




@dataclass
class 			snake_case__   (							datasets.BuilderConfig):

       '''simple docstring'''
       lowerCamelCase							:				Optional[datasets.Features] 				= None
       lowerCamelCase							:				str 				= "utf-8"
       lowerCamelCase							:				Optional[str] 				= None
       lowerCamelCase							:				Optional[str] 				= None
       lowerCamelCase							:				bool 				= True  # deprecated
       lowerCamelCase							:				Optional[int] 				= None  # deprecated
       lowerCamelCase							:				int 				= 10 << 20  # 10MB
       lowerCamelCase							:				Optional[bool] 				= None




class 			snake_case__   (							datasets.ArrowBasedBuilder):

       '''simple docstring'''
       lowerCamelCase							:				Optional[Any] 				= JsonConfig



       def 					__lowercase						(							self    ) ->      Optional[Any]:






            '''simple docstring'''





            if self.config.block_size is not None:
                 logger.warning("""The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead"""    )
                 __snake_case			:Optional[int]          =						self.config.block_size
            if self.config.use_threads is not True:
                 logger.warning(
                     """The JSON loader parameter `use_threads` is deprecated and doesn't have any effect anymore."""    )
            if self.config.newlines_in_values is not None:
                 raise ValueError("""The JSON loader parameter `newlines_in_values` is no longer supported"""    )
            return datasets.DatasetInfo(features=self.config.features    )



       def 					__lowercase						(							self			,						a__    ) ->      Optional[Any]:






            '''simple docstring'''





            if not self.config.data_files:
                 raise ValueError(F'''At least one data file must be specified, but got data_files={self.config.data_files}'''    )
            __snake_case			:Optional[int]          =						dl_manager.download_and_extract(self.config.data_files    )
            if isinstance(a__			,						(str, list, tuple)    ):
                 __snake_case			:str          =						data_files
                 if isinstance(a__			,						a__    ):
                      __snake_case			:Union[str, Any]          =						[files]
                 __snake_case			:str          =						[dl_manager.iter_files(a__    ) for file in files]
                 return [datasets.SplitGenerator(name=datasets.Split.TRAIN			,						gen_kwargs={"""files""": files}    )]
            __snake_case			:Any          =						[]
            for split_name, files in data_files.items():
                 if isinstance(a__			,						a__    ):
                      __snake_case			:Optional[Any]          =						[files]
                 __snake_case			:Dict          =						[dl_manager.iter_files(a__    ) for file in files]
                 splits.append(datasets.SplitGenerator(name=a__			,						gen_kwargs={"""files""": files}    )    )
            return splits



       def 					__lowercase						(							self			,						a__    ) ->      pa.Table:






            '''simple docstring'''





            if self.config.features is not None:
                 # adding missing columns
                 for column_name in set(self.config.features    ) - set(pa_table.column_names    ):
                      __snake_case			:Any          =						self.config.features.arrow_schema.field(a__    ).type
                      __snake_case			:List[str]          =						pa_table.append_column(a__			,						pa.array([None] * len(a__    )			,						type=a__    )    )
                 # more expensive cast to support nested structures with keys in a different order
                 # allows str <-> int/float or str to Audio for example
                 __snake_case			:Any          =						table_cast(a__			,						self.config.features.arrow_schema    )
            return pa_table



       def 					__lowercase						(							self			,						a__    ) ->      Dict:






            '''simple docstring'''





            for file_idx, file in enumerate(itertools.chain.from_iterable(a__    )    ):
                 # If the file is one json object and if we need to look at the list of items in one specific field
                 if self.config.field is not None:
                      with open(a__			,						encoding=self.config.encoding			,						errors=self.config.encoding_errors    ) as f:
                           __snake_case			:str          =						json.load(a__    )

                      # We keep only the field we are interested in
                      __snake_case			:Tuple          =						dataset[self.config.field]

                      # We accept two format: a list of dicts or a dict of lists
                      if isinstance(a__			,						(list, tuple)    ):
                           __snake_case			:Union[str, Any]          =						set().union(*[row.keys() for row in dataset]    )
                           __snake_case			:Optional[int]          =						{col: [row.get(a__    ) for row in dataset] for col in keys}
                      else:
                           __snake_case			:List[Any]          =						dataset
                      __snake_case			:Optional[Any]          =						pa.Table.from_pydict(a__    )
                      yield file_idx, self._cast_table(a__    )

                 # If the file has one json object per line
                 else:
                      with open(a__			,						"""rb"""    ) as f:
                           __snake_case			:Optional[Any]          =						0
                           # Use block_size equal to the chunk size divided by 32 to leverage multithreading
                           # Set a default minimum value of 16kB if the chunk size is really small
                           __snake_case			:Union[str, Any]          =						max(self.config.chunksize // 32			,						16 << 10    )
                           __snake_case			:Union[str, Any]          =						(
                               self.config.encoding_errors if self.config.encoding_errors is not None else """strict"""
                           )
                           while True:
                                __snake_case			:Dict          =						f.read(self.config.chunksize    )
                                if not batch:
                                     break
                                # Finish current line
                                try:
                                     batch += f.readline()
                                except (AttributeError, io.UnsupportedOperation):
                                     batch += readline(a__    )
                                # PyArrow only accepts utf-8 encoded bytes
                                if self.config.encoding != "utf-8":
                                     __snake_case			:Tuple          =						batch.decode(self.config.encoding			,						errors=a__    ).encode("""utf-8"""    )
                                try:
                                     while True:
                                          try:
                                               __snake_case			:Optional[int]          =						paj.read_json(
                                                   io.BytesIO(a__    )			,						read_options=paj.ReadOptions(block_size=a__    )    )
                                               break
                                          except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
                                               if (
                                                   isinstance(a__			,						pa.ArrowInvalid    )
                                                   and "straddling" not in str(a__    )
                                                   or block_size > len(a__    )
                                               ):
                                                    raise
                                               else:
                                                    # Increase the block size in case it was too small.
                                                    # The block size will be reset for the next file.
                                                    logger.debug(
                                                        F'''Batch of {len(a__    )} bytes couldn\'t be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}.'''    )
                                                    block_size *= 2
                                except pa.ArrowInvalid as e:
                                     try:
                                          with open(
                                              a__			,						encoding=self.config.encoding			,						errors=self.config.encoding_errors    ) as f:
                                               __snake_case			:Optional[Any]          =						json.load(a__    )
                                     except json.JSONDecodeError:
                                          logger.error(F'''Failed to read file \'{file}\' with error {type(a__    )}: {e}'''    )
                                          raise e
                                     # If possible, parse the file as a list of json objects and exit the loop
                                     if isinstance(a__			,						a__    ):  # list is the only sequence type supported in JSON
                                          try:
                                               __snake_case			:str          =						set().union(*[row.keys() for row in dataset]    )
                                               __snake_case			:List[Any]          =						{col: [row.get(a__    ) for row in dataset] for col in keys}
                                               __snake_case			:Union[str, Any]          =						pa.Table.from_pydict(a__    )
                                          except (pa.ArrowInvalid, AttributeError) as e:
                                               logger.error(F'''Failed to read file \'{file}\' with error {type(a__    )}: {e}'''    )
                                               raise ValueError(F'''Not able to read records in the JSON file at {file}.'''    ) from None
                                          yield file_idx, self._cast_table(a__    )
                                          break
                                     else:
                                          logger.error(F'''Failed to read file \'{file}\' with error {type(a__    )}: {e}'''    )
                                          raise ValueError(
                                              F'''Not able to read records in the JSON file at {file}. '''
                                              F'''You should probably indicate the field of the JSON file containing your records. '''
                                              F'''This JSON file contain the following fields: {str(list(dataset.keys()    )    )}. '''
                                              F'''Select the correct one and provide it as `field=\'XXX\'` to the dataset loading method. '''    ) from None
                        # Uncomment for debugging (will print the Arrow table size and elements)
                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                                yield (file_idx, batch_idx), self._cast_table(a__    )
                                batch_idx += 1










import os






def   UpperCamelCase  (       ):




     '''simple docstring'''






     __snake_case			:List[str]          =						os.path.dirname(os.path.realpath(snake_case__  )  )
     __snake_case			:Union[str, Any]          =						os.path.join(snake_case__	,"""triangle.txt"""  )

     with open(snake_case__  ) as f:
          __snake_case			:int          =						f.readlines()

     __snake_case			:int          =						[]
     for line in triangle:
          __snake_case			:List[Any]          =						[]
          for number in line.strip().split(""" """  ):
               numbers_from_line.append(int(snake_case__  )  )
          a.append(snake_case__  )

     for i in range(1	,len(snake_case__  )  ):
          for j in range(len(a[i]  )  ):
               __snake_case			:Union[str, Any]          =						a[i - 1][j] if j != len(a[i - 1]  ) else 0
               __snake_case			:Dict          =						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())


