




"""simple docstring"""




def 					a__				(       snake_case__ ,				snake_case__       )		->      Optional[int]:
			print("""\nThe shortest path matrix using Floyd Warshall algorithm\n"""       )
			for i in range(snake_case__       ):
						for j in range(snake_case__       ):
									if dist[i][j] != float("""inf"""       ):
												print(int(dist[i][j]       ) ,				end="""\t"""       )
									else:
												print("""INF""" ,				end="""\t"""       )
						print()



def 					a__				(       snake_case__ ,				snake_case__       )		->      str:
			lowerCamelCase       =      [[float("""inf"""       ) for _ in range(snake_case__       )] for _ in range(snake_case__       )]

			for i in range(snake_case__       ):
						for j in range(snake_case__       ):
									lowerCamelCase       =      graph[i][j]

									# check vertex k against all other vertices (i, j)
			for k in range(snake_case__       ):
						# looping through rows of graph array
						for i in range(snake_case__       ):
									# looping through columns of graph array
									for j in range(snake_case__       ):
												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(snake_case__ ,				snake_case__       )
			return dist, v


if __name__ == "__main__":
		lowerCAmelCase							:    Union[str, Any]  							=							int(input("""Enter number of vertices: """))
		lowerCAmelCase							:    Tuple  							=							int(input("""Enter number of edges: """))

		lowerCAmelCase							:    Tuple  							=							[[float("""inf""") for i in range(v)] for j in range(v)]

		for i in range(v):
				lowerCAmelCase							:    List[str]  							=							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							:    Optional[int]  							=							int(input("""Enter source:"""))
				lowerCAmelCase							:    Dict  							=							int(input("""Enter destination:"""))
				lowerCAmelCase							:    Optional[Any]  							=							float(input("""Enter weight:"""))
				lowerCAmelCase							:    Optional[int]  							=							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"""




from functools import lru_cache



def 					a__				(       snake_case__       )		->      set:
			lowerCamelCase       =      2
			lowerCamelCase       =      set()
			while i * i <= n:
						if n % i:
									i += 1
						else:
									n //= i
									factors.add(snake_case__       )
			if n > 1:
						factors.add(snake_case__       )
			return factors



@lru_cache
def 					a__				(       snake_case__       )		->      int:
			return len(unique_prime_factors(snake_case__       )       )



def 					a__				(       snake_case__       )		->      bool:
			return len(set(snake_case__       )       ) in (0, 1)



def 					a__				(       snake_case__       )		->      list:
			lowerCamelCase       =      2

			while True:
						# Increment each value of a generated range
						lowerCamelCase       =      [base + i for i in range(snake_case__       )]

						# Run elements through out unique_prime_factors function
						# Append our target number to the end.
						lowerCamelCase       =      [upf_len(snake_case__       ) for x in group]
						checker.append(snake_case__       )

						# If all numbers in the list are equal, return the group variable.
						if equality(snake_case__       ):
									return group

						# Increment our base variable by 1
						base += 1



def 					a__				(       snake_case__ = 4       )		->      int:
			lowerCamelCase       =      run(snake_case__       )
			return results[0] if len(snake_case__       ) else None


if __name__ == "__main__":
					print(solution())



