



def      UpperCamelCase(    __UpperCamelCase				:						Tuple	,__UpperCamelCase				:						List[str]					):
		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      UpperCamelCase(    __UpperCamelCase				:						Optional[int]	,__UpperCamelCase				:						int					):
		lowerCAmelCase_     :	Optional[Any]							   =					[[float('''inf'''					) for _ in range(a__					)] for _ in range(a__					)]

		for i in range(a__					):
				for j in range(a__					):
						lowerCAmelCase_     :	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]
								):
										lowerCAmelCase_     :	Any							   =					dist[i][k] + dist[k][j]

		_print_dist(a__	,a__					)
		return dist, v


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

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

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








def 							__SCREAMING_SNAKE_CASE     (   a__    :   int       )					->				int:
	if not isinstance(a__			,a__       ):
		raise TypeError("""Input value must be an 'int' type"""       )

	__A :			Union[str, Any]		    =			0
	while number:
		position += 1
		number >>= 1

	return position


if __name__ == "__main__":
			import doctest

			doctest.testmod()





