





"""simple docstring"""






def     __A      (			a_						:int   ,       a_						:str)		->		Dict:
				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_						:str   ,       a_						:str)		->		Optional[Any]:
				__a :						Optional[int]			       =  [[float('''inf''') for _ in range(a_)] for _ in range(a_)]

				for i in range(a_):
								for j in range(a_):
												__a :						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__":
		A 			=  int(input('''Enter number of vertices: '''))
		A 			=  int(input('''Enter number of edges: '''))

		A 			=  [[float('''inf''') for i in range(v)] for j in range(v)]

		for i in range(v):
				A 			=  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)
				A 			=  int(input('''Enter source:'''))
				A 			=  int(input('''Enter destination:'''))
				A 			=  float(input('''Enter weight:'''))
				A 			=  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






"""simple docstring"""






def     __A      (			a_						:int   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float(moles / volume) * nfactor)

def     __A      (			a_						:float   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float((moles * 0.0_8_2_1 * temperature) / (volume)))

def     __A      (			a_						:float   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float((moles * 0.0_8_2_1 * temperature) / (pressure)))

def     __A      (			a_						:float   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float((pressure * volume) / (0.0_8_2_1 * moles)))


if __name__ == "__main__":
		import doctest

		doctest.testmod()