

def 							__SCREAMING_SNAKE_CASE     (   a__    :   Tuple			,a__    :   List[str]       )					->				Tuple:
	print("""\nThe shortest path matrix using Floyd Warshall algorithm\n"""       )
	for i in range(a__       ):
		for j in range(a__       ):
			if dist[i][j] != float("""inf"""       ):
				print(int(dist[i][j]       )			,end="""\t"""       )
			else:
				print("""INF"""			,end="""\t"""       )
		print()
def 							__SCREAMING_SNAKE_CASE     (   a__    :   Optional[int]			,a__    :   int       )					->				Any:
	__A :			Optional[Any]		    =			[[float("""inf"""       ) for _ in range(a__       )] for _ in range(a__       )]

	for i in range(a__       ):
		for j in range(a__       ):
			__A :			Union[str, Any]		    =			graph[i][j]

			# check vertex k against all other vertices (i, j)
	for k in range(a__       ):
		# looping through rows of graph array
		for i in range(a__       ):
			# looping through columns of graph array
			for j in range(a__       ):
				if (
				    dist[i][k] != float("""inf"""       )
				    and dist[k][j] != float("""inf"""       )
				    and dist[i][k] + dist[k][j] < dist[i][j]
				):
					__A :			Any		    =			dist[i][k] + dist[k][j]

	_print_dist(a__			,a__       )
	return dist, v


if __name__ == "__main__":
			UpperCAmelCase_							:					str		 =   int(input('''Enter number of vertices: '''))
			UpperCAmelCase_							:					List[Any]		 =   int(input('''Enter number of edges: '''))

			UpperCAmelCase_							:					int		 =   [[float('''inf''') for i in range(v)] for j in range(v)]

			for i in range(v):
						UpperCAmelCase_							:					Union[str, Any]		 =   0.0

						# src and dst are indices that must be within the array size graph[e][v]
						# failure to follow this will result in an error
			for i in range(e):
						print('''\nEdge ''', i + 1)
						UpperCAmelCase_							:					int		 =   int(input('''Enter source:'''))
						UpperCAmelCase_							:					Tuple		 =   int(input('''Enter destination:'''))
						UpperCAmelCase_							:					int		 =   float(input('''Enter weight:'''))
						UpperCAmelCase_							:					List[Any]		 =   weight

			floyd_warshall(graph, v)

			# Example Input
			# Enter number of vertices: 3
			# Enter number of edges: 2

			# # generated graph from vertex and edge inputs
			# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
			# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

			# specify source, destination and weight for edge #1
			# Edge  1
			# Enter source:1
			# Enter destination:2
			# Enter weight:2

			# specify source, destination and weight for edge #2
			# Edge  2
			# Enter source:2
			# Enter destination:1
			# Enter weight:1

			# # Expected Output from the vertice, edge and src, dst, weight inputs!!
			# 0		INF	INF
			# INF	0	2
			# INF	1	0








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     (   )					->				Tuple:
	__A :			List[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=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 							__SCREAMING_SNAKE_CASE     (   )					->				str:
	__A :			Union[str, Any]		    =			parse_args()

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

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





