





import math





def  __magic_name__  (				lowercase				)				-> str:

							"""simple docstring"""



							lowercase_	:   Any  				=     0
							lowercase_	:   List[Any]  				=     0
							while num > 0:
														lowercase_	:   Any  				=     num % 8
														lowercase_	:   List[Any]  				=     octal + (remainder * math.floor(math.pow(10				,       lowercase				)				))
														counter += 1
														lowercase_	:   Tuple  				=     math.floor(num / 8				)  # basically /= 8 without remainder if any
														# This formatting removes trailing '.0' from `octal`.
							return f"""0o{int(lowercase				)}"""





def  __magic_name__  (				)				-> None:

							"""simple docstring"""



							print("""\n2 in octal is:"""				)
							print(decimal_to_octal(2				)				)  # = 2
							print("""\n8 in octal is:"""				)
							print(decimal_to_octal(8				)				)  # = 10
							print("""\n65 in octal is:"""				)
							print(decimal_to_octal(65				)				)  # = 101
							print("""\n216 in octal is:"""				)
							print(decimal_to_octal(216				)				)  # = 330
							print("""\n512 in octal is:"""				)
							print(decimal_to_octal(512				)				)  # = 1000
							print("""\n"""				)


if __name__ == "__main__":
							main()






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

import torch_xla.distributed.xla_multiprocessing as xmp





def  __magic_name__  (				)				-> str:

							"""simple docstring"""



							lowercase_	:   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=lowercase				,       default=1				,       help="""Number of TPU cores to use (1 or 8)."""				)

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

							return parser.parse_args()





def  __magic_name__  (				)				-> List[Any]:

							"""simple docstring"""



							lowercase_	:   Union[str, Any]  				=     parse_args()

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

							# Patch sys.argv
							lowercase_	:   Optional[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()