






def 							lowerCamelCase__ (       __lowerCamelCase     :	Optional[int]    ,						__lowerCamelCase     :	str						):
  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 							lowerCamelCase__ (       __lowerCamelCase     :	Union[str, Any]    ,						__lowerCamelCase     :	Dict						):
  __UpperCAmelCase				:      List[Any]	 =    [[float("""inf"""						) for _ in range(__lowerCamelCase						)] for _ in range(__lowerCamelCase						)]

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

  _print_dist(__lowerCamelCase    ,						__lowerCamelCase						)
  return dist, v


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

       a						:			List[Any]     	=					[[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						:			str     	=					int(input("Enter source:"))
              a						:			Optional[int]     	=					int(input("Enter destination:"))
              a						:			Optional[Any]     	=					float(input("Enter weight:"))
              a						:			Union[str, Any]     	=					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





def 	a (     A__      :  int	)       -> bool:





      """simple docstring"""



      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...')
  lowercase_   							=  int(input('Enter number: ').strip())
  print(f"{number} is {'' if perfect(number) else 'not '}a Perfect Number.")


