


def 						a__			(				A__,      A__				):
			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 						a__			(				A__,      A__				):
			SCREAMING_SNAKE_CASE_		:     Dict					=					[[float('inf'				) for _ in range(A__				)] for _ in range(A__				)]

			for i in range(A__				):
						for j in range(A__				):
									SCREAMING_SNAKE_CASE_		:     Dict					=					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]
												):
															SCREAMING_SNAKE_CASE_		:     str					=					dist[i][k] + dist[k][j]

			_print_dist(A__,      A__				)
			return dist, v


if __name__ == "__main__":
				lowerCAmelCase__			:      Optional[Any]								=int(input('Enter number of vertices: '))
				lowerCAmelCase__			:      Optional[int]								=int(input('Enter number of edges: '))

				lowerCAmelCase__			:      Dict								=[[float('inf') for i in range(v)] for j in range(v)]

				for i in range(v):
								lowerCAmelCase__			:      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)
								lowerCAmelCase__			:      List[Any]								=int(input('Enter source:'))
								lowerCAmelCase__			:      List[Any]								=int(input('Enter destination:'))
								lowerCAmelCase__			:      Union[str, Any]								=float(input('Enter weight:'))
								lowerCAmelCase__			:      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 enum
import shutil
import sys


__UpperCamelCase,	__UpperCamelCase:	Optional[int] = shutil.get_terminal_size()

__UpperCamelCase:	Optional[Any] = {"""UP""": """A""", """DOWN""": """B""", """RIGHT""": """C""", """LEFT""": """D"""}


class       __lowerCAmelCase					(       enum.Enum      ):


	'''simple docstring'''





	_A													=				0
	_A													=				1


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : List[Any]   ,    _lowercase     : Union[str, Any]=""			)   ->							int:




		'''simple docstring'''
		sys.stdout.write(str(_lowercase			) + end			)
		sys.stdout.flush()


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : Optional[Any]   ,    _lowercase     : Union[str, Any]   ,    _lowercase     : Optional[int]=""			)   ->							str:




		'''simple docstring'''
		forceWrite(f"""\u001b[{color}m{content}\u001b[0m"""   ,    _lowercase			)


def       SCREAMING_SNAKE_CASE__  (       )   ->							int:




		'''simple docstring'''
		forceWrite('\r'			)


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : int   ,    _lowercase     : str			)   ->							List[Any]:




		'''simple docstring'''
		forceWrite(f"""\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}"""			)


def       SCREAMING_SNAKE_CASE__  (       )   ->							Dict:




		'''simple docstring'''
		forceWrite(' ' * TERMINAL_WIDTH			)
		reset_cursor()





def       SCREAMING_SNAKE_CASE__  (       )   ->							List[str]:




		'''simple docstring'''
		reset_cursor()
		forceWrite('-' * TERMINAL_WIDTH			)


