





import heapq as hq
import math
from collections.abc import Iterator



class       A__     :





      def __init__(				self ,							A_     ):
       '''simple docstring'''




       UpperCamelCase			:      Union[str, Any] 			=     str(id_     )
       UpperCamelCase			:      Dict 			=     None
       UpperCamelCase			:      Tuple 			=     None
       UpperCamelCase			:      Tuple 			=     []
       UpperCamelCase			:      List[str] 			=     {}  # {vertex:distance}





      def __lt__(				self ,							A_     ):
       '''simple docstring'''




       return self.key < other.key





      def __repr__(				self     ):
       '''simple docstring'''




       return self.id





      def  __UpperCamelCase(				self ,							A_     ):
       '''simple docstring'''




       self.neighbors.append(A_     )





      def  __UpperCamelCase(				self ,							A_ ,							A_     ):
       '''simple docstring'''




       UpperCamelCase			:      Union[str, Any] 			=     weight



def 	A_       (  _lowerCAmelCase							,     _lowerCAmelCase							,     _lowerCAmelCase							,     _lowerCAmelCase  )		->				List[Any]:
 # add the neighbors:
 graph[a - 1].add_neighbor(graph[b - 1]  )
 graph[b - 1].add_neighbor(graph[a - 1]  )
 # add the edges:
 graph[a - 1].add_edge(graph[b - 1]							,     _lowerCAmelCase  )
 graph[b - 1].add_edge(graph[a - 1]							,     _lowerCAmelCase  )



def 	A_       (  _lowerCAmelCase							,     _lowerCAmelCase  )		->				list:
 UpperCamelCase			:      int 			=     []
 for u in graph:
  UpperCamelCase			:      List[Any] 			=     math.inf
  UpperCamelCase			:      Optional[Any] 			=     None
 UpperCamelCase			:      Tuple 			=     0
 UpperCamelCase			:      Any 			=     graph[:]
 while q:
  UpperCamelCase			:      Any 			=     min(_lowerCAmelCase  )
  q.remove(_lowerCAmelCase  )
  for v in u.neighbors:
   if (v in q) and (u.edges[v.id] < v.key):
    UpperCamelCase			:      Optional[int] 			=     u
    UpperCamelCase			:      Tuple 			=     u.edges[v.id]
 for i in range(1							,     len(_lowerCAmelCase  )  ):
  a.append((int(graph[i].id  ) + 1, int(graph[i].pi.id  ) + 1)  )
 return a



def 	A_       (  _lowerCAmelCase							,     _lowerCAmelCase  )		->				Iterator[tuple]:
 for u in graph:
  UpperCamelCase			:      Any 			=     math.inf
  UpperCamelCase			:      str 			=     None
 UpperCamelCase			:      List[Any] 			=     0

 UpperCamelCase			:      Tuple 			=     list(_lowerCAmelCase  )
 hq.heapify(_lowerCAmelCase  )

 while h:
  UpperCamelCase			:      Any 			=     hq.heappop(_lowerCAmelCase  )
  for v in u.neighbors:
   if (v in h) and (u.edges[v.id] < v.key):
    UpperCamelCase			:      Optional[Any] 			=     u
    UpperCamelCase			:      Optional[int] 			=     u.edges[v.id]
    hq.heapify(_lowerCAmelCase  )

 for i in range(1							,     len(_lowerCAmelCase  )  ):
  yield (int(graph[i].id  ) + 1, int(graph[i].pi.id  ) + 1)



def 	A_       (  )		->				None:
 pass


if __name__ == "__main__":
    import doctest

    doctest.testmod()







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

import torch_xla.distributed.xla_multiprocessing as xmp



def 	A_       (  )		->				Dict:
 UpperCamelCase			:      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=_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 	A_       (  )		->				Optional[int]:
 UpperCamelCase			:      Tuple 			=     parse_args()

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

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