


'''simple docstring'''






def      UpperCAmelCase      (		lowerCamelCase_  :Tuple				,      lowerCamelCase_  :Dict ):







		'''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      UpperCAmelCase      (		lowerCamelCase_  :Dict				,      lowerCamelCase_  :Tuple ):







		'''simple docstring'''
		snake_case_		:							List[Any]			       =						[[float("""inf""" ) for _ in range(_UpperCamelCase )] for _ in range(_UpperCamelCase )]

		for i in range(_UpperCamelCase ):
				for j in range(_UpperCamelCase ):
						snake_case_		:							Optional[int]			       =						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_		:							Tuple			       =						dist[i][k] + dist[k][j]

		_print_dist(_UpperCamelCase				,      _UpperCamelCase )
		return dist, v


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

				__A	:	List[str]     =     [[float('inf') for i in range(v)] for j in range(v)]

				for i in range(v):
								__A	:	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	:	Tuple     =     int(input('Enter source:'))
								__A	:	List[str]     =     int(input('Enter destination:'))
								__A	:	str     =     float(input('Enter weight:'))
								__A	:	Tuple     =     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 __future__ import annotations





def      UpperCAmelCase      (		lowerCamelCase_  :int ):







		'''simple docstring'''
		snake_case_		:							List[str]			       =						[True] * limit
		snake_case_		:							Union[str, Any]			       =						False
		snake_case_		:							List[str]			       =						False
		snake_case_		:							Any			       =						True

		for i in range(3				,      int(limit**0.5 + 1 )				,      2 ):
				snake_case_		:							Tuple			       =						i * 2
				while index < limit:
						snake_case_		:							Any			       =						False
						snake_case_		:							Optional[Any]			       =						index + i

		snake_case_		:							List[str]			       =						[2]

		for i in range(3				,      lowerCamelCase_				,      2 ):
				if is_prime[i]:
						primes.append(lowerCamelCase_ )

		return primes





def      UpperCAmelCase      (		lowerCamelCase_  :int = 1_00_00_00 ):







		'''simple docstring'''
		snake_case_		:							Optional[int]			       =						prime_sieve(lowerCamelCase_ )
		snake_case_		:							Optional[Any]			       =						0
		snake_case_		:							Optional[int]			       =						0

		for i in range(len(lowerCamelCase_ ) ):
				for j in range(i + length				,      len(lowerCamelCase_ ) ):
						snake_case_		:							Optional[int]			       =						sum(primes[i:j] )
						if sol >= ceiling:
								break

						if sol in primes:
								snake_case_		:							Optional[Any]			       =						j - i
								snake_case_		:							Tuple			       =						sol

		return largest


if __name__ == "__main__":
							print(F'{solution() = }')