





def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :Dict			,							snake_case__  :int     )      ->						str:
  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 							SCREAMING_SNAKE_CASE__       (  snake_case__  :List[str]			,							snake_case__  :Dict     )      ->						str:
  _lowercase							= [[float('inf'     ) for _ in range(snake_case__     )] for _ in range(snake_case__     )]

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

  _print_dist(snake_case__			,							snake_case__     )
  return dist, v


if __name__ == "__main__":
      snake_case 				=       int(input("""Enter number of vertices: """))
      snake_case 				=       int(input("""Enter number of edges: """))

      snake_case 				=       [[float("""inf""") for i in range(v)] for j in range(v)]

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






from __future__ import annotations

from collections.abc import Generator

def 							SCREAMING_SNAKE_CASE__       (  )      ->						Generator[int, None, None]:
  _lowercase							= {}
  _lowercase							= 2
  while True:
    _lowercase							= factor_map.pop(snake_case__			,							snake_case__     )
    if factor:
      _lowercase							= factor + prime
      while x in factor_map:
        x += factor
      _lowercase							= factor
    else:
      _lowercase							= prime
      yield prime
    prime += 1

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :float = 1E10     )      ->						int:
  _lowercase							= sieve()

  _lowercase							= 1
  while True:
    _lowercase							= next(snake_case__     )
    if (2 * prime * n) > limit:
      return n
    # Ignore the next prime as the reminder will be 2.
    next(snake_case__     )
    n += 2


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