"""simple docstring"""




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





def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: List[str]    ,_lowerCamelCase		: Union[str, Any]			) ->   str:
  _lowerCAmelCase		: List[str]						    =  [[float("""inf"""			) for _ in range(_lowerCamelCase			)] for _ in range(_lowerCamelCase			)]

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

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

  _print_dist(_lowerCamelCase    ,_lowerCamelCase			)
  return dist, v


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

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

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




def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: int			) ->   bool:
  return sum(i for i in range(1    ,number // 2 + 1			) if number % i == 0			) == number


if __name__ == "__main__":
     print('Program to check whether a number is a Perfect number or not...')
     _a   :	int 					=     int(input('Enter number: ').strip())
     print(F"""{number} is {"" if perfect(number) else "not "}a Perfect Number.""")




