






'''simple docstring'''

from __future__ import annotations

from collections import deque
from queue import Queue
from timeit import timeit

A:   List[Any]						=					{
    "A": ["B", "C"],
    "B": ["A", "D", "E"],
    "C": ["A", "F"],
    "D": ["B"],
    "E": ["B", "F"],
    "F": ["C", "E"],
}






def 						_UpperCAmelCase     (	a		:						dict    ,      a		:						str				)      ->      list[str]:





						"""simple docstring"""
						lowercase_   : Optional[int]   	=      {start}
						lowercase_   : Dict   	=      [start]
						lowercase_   : Queue   	=      Queue()
						queue.put(a				)
						while not queue.empty():
												lowercase_   : Optional[Any]   	=      queue.get()
												for w in graph[v]:
																		if w not in explored:
																								explored.add(a				)
																								result.append(a				)
																								queue.put(a				)
						return result






def 						_UpperCAmelCase     (	a		:						dict    ,      a		:						str				)      ->      list[str]:





						"""simple docstring"""
						lowercase_   : Dict   	=      {start}
						lowercase_   : int   	=      [start]
						lowercase_   : List[str]   	=      deque([start]				)
						while queue:
												lowercase_   : Any   	=      queue.popleft()
												for child in graph[v]:
																		if child not in visited:
																								visited.add(a				)
																								result.append(a				)
																								queue.append(a				)
						return result






def 						_UpperCAmelCase     (	a		:						str				)      ->      None:





						"""simple docstring"""
						lowercase_   : str   	=      f"from __main__ import G, {name}"
						lowercase_   : str   	=      1_0_0_0_0
						lowercase_   : str   	=      timeit(f"{name}(G, 'A')"    ,      setup=a    ,      number=a				)
						print(f"{name:<35} finished {number} runs in {res:.5f} seconds"				)


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						benchmark_function("breadth_first_search")
						benchmark_function("breadth_first_search_with_deque")
						# breadth_first_search                finished 10000 runs in 0.20999 seconds
						# breadth_first_search_with_deque     finished 10000 runs in 0.01421 seconds








'''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     (	)      ->      Optional[Any]:





						"""simple docstring"""
						lowercase_   : List[str]   	=      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=a    ,      default=1    ,      help='Number of TPU cores to use (1 or 8).'				)

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

						return parser.parse_args()






def 						_UpperCAmelCase     (	)      ->      str:





						"""simple docstring"""
						lowercase_   : Optional[int]   	=      parse_args()

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

						# Patch sys.argv
						lowercase_   : List[str]   	=      [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()
