



"""simple docstring"""





def 	__lowerCAmelCase						(		__UpperCamelCase      :			Dict					, __UpperCamelCase      :			List[Any]    ):


						'''simple docstring'''






						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      :			Union[str, Any]					, __UpperCamelCase      :			List[Any]    ):


						'''simple docstring'''






						snake_case_   : Optional[Any]						=			[[float("""inf"""    ) for _ in range(__UpperCamelCase    )] for _ in range(__UpperCamelCase    )]

						for i in range(__UpperCamelCase    ):
												for j in range(__UpperCamelCase    ):
																		snake_case_   : List[Any]						=			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]
																								):
																														snake_case_   : Optional[Any]						=			dist[i][k] + dist[k][j]

						_print_dist(__UpperCamelCase					, __UpperCamelCase    )
						return dist, v


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

					__lowerCAmelCase       :					Any      					=					[[float('''inf''') for i in range(v)] for j in range(v)]

					for i in range(v):
										__lowerCAmelCase       :					Tuple      					=					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       :					Tuple      					=					int(input('''Enter destination:'''))
										__lowerCAmelCase       :					List[Any]      					=					float(input('''Enter weight:'''))
										__lowerCAmelCase       :					Dict      					=					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 	__lowerCAmelCase						(		__UpperCamelCase      :			int					, __UpperCamelCase      :			int    ):


						'''simple docstring'''






						if a < 0 or b < 0:
												raise ValueError("""the value of both inputs must be positive"""    )

						snake_case_   : List[str]						=			str(bin(__UpperCamelCase    )    )[2:]  # remove the leading "0b"
						snake_case_   : Union[str, Any]						=			str(bin(__UpperCamelCase    )    )[2:]  # remove the leading "0b"

						snake_case_   : int						=			max(len(__UpperCamelCase    )					, len(__UpperCamelCase    )    )

						return "0b" + "".join(
						    str(int(char_a != char_b    )    )
						    for char_a, char_b in zip(a_binary.zfill(__UpperCamelCase    )					, b_binary.zfill(__UpperCamelCase    )    )    )


if __name__ == "__main__":
					import doctest

					doctest.testmod()

