def 	lowerCamelCase					(	UpperCamelCase     :				Dict			,       UpperCamelCase     :				str							)   ->    List[str]:
		print('\nThe shortest path matrix using Floyd Warshall algorithm\n'							)
		for i in range(UpperCamelCase							):
				for j in range(UpperCamelCase							):
						if dist[i][j] != float('inf'							):
								print(int(dist[i][j]							)			,       end='\t'							)
						else:
								print('INF'			,       end='\t'							)
				print()


def 	lowerCamelCase					(	UpperCamelCase     :				int			,       UpperCamelCase     :				str							)   ->    Dict:
		_lowerCamelCase				   =  [[float('inf'							) for _ in range(UpperCamelCase							)] for _ in range(UpperCamelCase							)]

		for i in range(UpperCamelCase							):
				for j in range(UpperCamelCase							):
						_lowerCamelCase				   =  graph[i][j]

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

		_print_dist(UpperCamelCase			,       UpperCamelCase							)
		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
def 	lowerCamelCase					(	UpperCamelCase     :				int			,       UpperCamelCase     :				int							)   ->    str:
		if number < 0 or shift_amount < 0:
				raise ValueError('both inputs must be positive integers'							)

		_lowerCamelCase				   =  str(bin(UpperCamelCase							)							)
		binary_number += "0" * shift_amount
		return binary_number


def 	lowerCamelCase					(	UpperCamelCase     :				int			,       UpperCamelCase     :				int							)   ->    str:
		if number < 0 or shift_amount < 0:
				raise ValueError('both inputs must be positive integers'							)

		_lowerCamelCase				   =  str(bin(UpperCamelCase							)							)[2:]
		if shift_amount >= len(UpperCamelCase							):
				return "0b0"
		_lowerCamelCase				   =  binary_number[: len(UpperCamelCase							) - shift_amount]
		return "0b" + shifted_binary_number


def 	lowerCamelCase					(	UpperCamelCase     :				int			,       UpperCamelCase     :				int							)   ->    str:
		if number >= 0:  # Get binary representation of positive number
				_lowerCamelCase				   =  '0' + str(bin(UpperCamelCase							)							).strip('-'							)[2:]
		else:  # Get binary (2's complement) representation of negative number
				_lowerCamelCase				   =  len(bin(UpperCamelCase							)[3:]							)  # Find 2's complement of number
				_lowerCamelCase				   =  bin(abs(UpperCamelCase							) - (1 << binary_number_length)							)[3:]
				_lowerCamelCase				   =  (
				    '1' + '0' * (binary_number_length - len(UpperCamelCase							)) + binary_number
				)

		if shift_amount >= len(UpperCamelCase							):
				return "0b" + binary_number[0] * len(UpperCamelCase							)
		return (
		    "0b"
		    + binary_number[0] * shift_amount
		    + binary_number[: len(UpperCamelCase							) - shift_amount]
		)


if __name__ == "__main__":
				import doctest

				doctest.testmod()