






import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp






def   UpperCamelCase  (       ):




     '''simple docstring'''






     __snake_case			:Optional[int]          =						ArgumentParser(
         description=(
             """PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"""
         )  )

     # Optional arguments for the launch helper
     parser.add_argument("""--num_cores"""	,type=snake_case__	,default=1	,help="""Number of TPU cores to use (1 or 8)."""  )

     # positional
     parser.add_argument(
         """training_script"""	,type=snake_case__	,help=(
             """The full path to the single TPU training """
             """program/script to be launched in parallel, """
             """followed by all the arguments for the """
             """training script"""
         )	,)

     # rest from the training program
     parser.add_argument("""training_script_args"""	,nargs=snake_case__  )

     return parser.parse_args()






def   UpperCamelCase  (       ):




     '''simple docstring'''






     __snake_case			:Optional[Any]          =						parse_args()

     # Import training_script as a module.
     __snake_case			:List[Any]          =						Path(args.training_script  )
     sys.path.append(str(script_fpath.parent.resolve()  )  )
     __snake_case			:List[str]          =						script_fpath.stem
     __snake_case			:str          =						importlib.import_module(snake_case__  )

     # Patch sys.argv
     __snake_case			:Optional[Any]          =						[args.training_script] + args.training_script_args + ["""--tpu_num_cores""", str(args.num_cores  )]

     xmp.spawn(mod._mp_fn	,args=()	,nprocs=args.num_cores  )


if __name__ == "__main__":
     main()










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())


