"""simple docstring"""




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

import torch_xla.distributed.xla_multiprocessing as xmp





def 							SCREAMING_SNAKE_CASE     (			)       ->      str:
  _lowerCAmelCase						:       Optional[Any]  			=     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=_lowerCamelCase			,default=1			,help="""Number of TPU cores to use (1 or 8)."""	)

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

  return parser.parse_args()





def 							SCREAMING_SNAKE_CASE     (			)       ->      Optional[Any]:
  _lowerCAmelCase						:       List[Any]  			=     parse_args()

  # Import training_script as a module.
  _lowerCAmelCase						:       Optional[Any]  			=     Path(args.training_script	)
  sys.path.append(str(script_fpath.parent.resolve()	)	)
  _lowerCAmelCase						:       Union[str, Any]  			=     script_fpath.stem
  _lowerCAmelCase						:       Optional[Any]  			=     importlib.import_module(_lowerCamelCase	)

  # Patch sys.argv
  _lowerCAmelCase						:       Tuple  			=     [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			)					->int:





  """simple docstring"""


  if not isinstance(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			):
    lowerCAmelCase__			:Dict											=							F"Input value of [number={number}] must be an integer"
    raise TypeError(_SCREAMING_SNAKE_CASE			)

  if number < 1:
    lowerCAmelCase__			:Dict											=							F"Input value of [number={number}] must be > 0"
    raise ValueError(_SCREAMING_SNAKE_CASE			)
  elif number == 1:
    return 3
  elif number == 2:
    return 5
  else:
    lowerCAmelCase__			:Union[str, Any]											=							int(math.log(number // 3     ,   2			)			) + 2

    lowerCAmelCase__			:Optional[Any]											=							[3, 5]
    lowerCAmelCase__			:Optional[Any]											=							2
    lowerCAmelCase__			:List[str]											=							3
    for block in range(1     ,   _SCREAMING_SNAKE_CASE			):
      for _ in range(_SCREAMING_SNAKE_CASE			):
        proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1]			)
        proth_index += 1
      increment *= 2

  return proth_list[number - 1]


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  for number in range(11):
    __A											=		0
    try:
      __A											=		proth(number)
    except ValueError:
      print(F'''ValueError: there is no {number}th Proth number''')
      continue

    print(F'''The {number}th Proth number: {value}''')
