'''simple docstring'''




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

import torch_xla.distributed.xla_multiprocessing as xmp





def 	_UpperCAmelCase       (				)      -> Tuple:
    A_      =  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=_UpperCamelCase,  default=1,  help='''Number of TPU cores to use (1 or 8).'''  )

    # positional
    parser.add_argument(
        '''training_script''',  type=_UpperCamelCase,  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=_UpperCamelCase  )

    return parser.parse_args()





def 	_UpperCAmelCase       (				)      -> Union[str, Any]:
    A_      =  parse_args()

    # Import training_script as a module.
    A_      =  Path(args.training_script  )
    sys.path.append(str(script_fpath.parent.resolve()  )  )
    A_      =  script_fpath.stem
    A_      =  importlib.import_module(_UpperCamelCase  )

    # Patch sys.argv
    A_      =  [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()







'''simple docstring'''




__snake_case  : str		       =    10**8





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int  )      -> bool:
    if n % 10 == 0:
        return False
    A_      =  str(_UpperCamelCase  )
    return s == s[::-1]





def 	_UpperCAmelCase       (				)      -> int:
    A_      =  set()
    A_      =  1
    A_      =  5
    while sum_squares < LIMIT:
        A_      =  first_square + 1
        while sum_squares < LIMIT:
            if is_palindrome(_UpperCamelCase  ):
                answer.add(_UpperCamelCase  )
            last_square += 1
            sum_squares += last_square**2
        first_square += 1
        A_      =  first_square**2 + (first_square + 1) ** 2

    return sum(_UpperCamelCase  )


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






