"""simple docstring"""
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp







def 						__a       (     )     ->List[Any]:
  a__:					Tuple      							=     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 						__a       (     )     ->Optional[int]:
  a__:					Any      							=     parse_args()

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

  # Patch sys.argv
  a__:					int      							=     [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"""
import math







def 						__a       (     _SCREAMING_SNAKE_CASE		,					_SCREAMING_SNAKE_CASE       )     ->Optional[int]:
  if 0 not in (x, y):
    # We use the relation x^y = y*log10(x), where 10 is the base.
    return y * math.logaa(_SCREAMING_SNAKE_CASE       )
  else:
    if x == 0:  # 0 raised to any number is 0
      return 0
    elif y == 0:
      return 1  # any number raised to 0 is 1
  raise AssertionError('This should never happen'       )


if __name__ == "__main__":  # Main function
 # Read two numbers from input and typecast them to int using map function.
 # Here x is the base and y is the power.
 lowercase__ 	=     'Enter the base and the power separated by a comma: '
 lowercase__	, lowercase__ 	=     map(int, input(prompt).split(','))
 lowercase__	, lowercase__ 	=     map(int, input(prompt).split(','))

 # We find the log of each number, using the function res(), which takes two
 # arguments.
 lowercase__ 	=     res(xa, ya)
 lowercase__ 	=     res(xa, ya)

 # We check for the largest number
 if resa > resa:
  print('Largest number is', xa, '^', ya)
 elif resa > resa:
  print('Largest number is', xa, '^', ya)
 else:
  print('Both are equal')


