



"""simple docstring"""
def  lowerCamelCase_						(UpperCamelCase__		:		Optional[Any]     ,       UpperCamelCase__		:		List[str]							):
    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  lowerCamelCase_						(UpperCamelCase__		:		Optional[int]     ,       UpperCamelCase__		:		str							):
    _UpperCAmelCase							:  Tuple											=    [[float('''inf'''							) for _ in range(UpperCamelCase__							)] for _ in range(UpperCamelCase__							)]

    for i in range(UpperCamelCase__							):
        for j in range(UpperCamelCase__							):
            _UpperCAmelCase							:  str											=    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]
                ):
                    _UpperCAmelCase							:  List[str]											=    dist[i][k] + dist[k][j]

    _print_dist(UpperCamelCase__     ,       UpperCamelCase__							)
    return dist, v


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

  _lowerCAmelCase    :Optional[int]     =					[[float('inf') for i in range(v)] for j in range(v)]

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







"""simple docstring"""
def  lowerCamelCase_						(UpperCamelCase__		:		int							):
    if not isinstance(UpperCamelCase__     ,       UpperCamelCase__							) or number < 0:
        raise ValueError('''Input must be a non-negative integer'''							)

    _UpperCAmelCase							:  str											=    0
    while number:
        # This way we arrive at next set bit (next 1) instead of looping
        # through each bit and checking for 1s hence the
        # loop won't run 32 times it will only run the number of `1` times
        number &= number - 1
        count += 1
    return count


if __name__ == "__main__":
  import doctest

  doctest.testmod()


