CPLIB_GRAPH_TSP = 1

proc to_adjacency_matrix(G: WeightedDirectedGraph[float32] or
    WeightedDirectedStaticGraph[float32]; none: float32 = 1e+30'f32): seq[
    seq[float32]]

proc to_adjacency_matrix(G: WeightedDirectedGraph[float] or
    WeightedDirectedStaticGraph[float]; none: float = 1e+100): seq[seq[float]]

proc to_adjacency_matrix(G: WeightedDirectedGraph[int32] or
    WeightedDirectedStaticGraph[int32]; none: int32 = INF32): seq[seq[int32]]

proc to_adjacency_matrix(G: WeightedDirectedGraph[int] or
    WeightedDirectedStaticGraph[int]; none: int = INF64): seq[seq[int]]

proc to_adjacency_matrix[T](G: WeightedDirectedGraph[T] or
    WeightedDirectedStaticGraph[T]; none: T): seq[seq[T]]

proc toContractionGraph(G: UnWeightedGraph; v: openArray[int]): WeightedDirectedGraph[
    int]

proc toContractionGraph(G: WeightedGraph[float32]; v: openArray[int]): WeightedDirectedGraph[
    float32]

proc toContractionGraph(G: WeightedGraph[float]; v: openArray[int]): WeightedDirectedGraph[
    float]

proc toContractionGraph(G: WeightedGraph[int32]; v: openArray[int]): WeightedDirectedGraph[
    int32]

proc toContractionGraph(G: WeightedGraph[int]; v: openArray[int]): WeightedDirectedGraph[
    int]

proc toContractionGraph[T](G: WeightedGraph[T]; v: openArray[int]; ZERO, INF: T): WeightedDirectedGraph[
    T]

proc tspPathAnyStart(dist: openArray[seq[float32]]; floydwarshall: bool = true): float32 {.
    ...raises: [], tags: [].}

proc tspPathAnyStart(dist: openArray[seq[float]]; floydwarshall: bool = true): float {.
    ...raises: [], tags: [].}

proc tspPathAnyStart(dist: openArray[seq[int32]]; floydwarshall: bool = true): int32 {.
    ...raises: [], tags: [].}

proc tspPathAnyStart(dist: openArray[seq[int]]; floydwarshall: bool = true): int {.
    ...raises: [], tags: [].}

proc tspPathAnyStart[T](dist: openArray[seq[T]]; zero, inf: T;
                        floydwarshall: bool = true): T

proc tspPathCostFrom(dist: openArray[seq[float32]]; start_v: int;
                     floydwarshall: bool = true): float32 {....raises: [], tags: [].}

proc tspPathCostFrom(dist: openArray[seq[float]]; start_v: int;
                     floydwarshall: bool = true): float {....raises: [], tags: [].}

proc tspPathCostFrom(dist: openArray[seq[int32]]; start_v: int;
                     floydwarshall: bool = true): int32 {....raises: [], tags: [].}

proc tspPathCostFrom(dist: openArray[seq[int]]; start_v: int;
                     floydwarshall: bool = true): int {....raises: [], tags: [].}

proc tspPathCostFrom[T](dist: openArray[seq[T]]; start_v: int; zero, inf: T;
                        floydwarshall: bool = true): T

proc tspPathCostFromTo(dist: openArray[seq[float32]]; start_v, goal_v: int;
                       floydwarshall: bool = true): float32 {....raises: [],
    tags: [].}

proc tspPathCostFromTo(dist: openArray[seq[float]]; start_v, goal_v: int;
                       floydwarshall: bool = true): float {....raises: [], tags: [].}

proc tspPathCostFromTo(dist: openArray[seq[int32]]; start_v, goal_v: int;
                       floydwarshall: bool = true): int32 {....raises: [], tags: [].}

proc tspPathCostFromTo(dist: openArray[seq[int]]; start_v, goal_v: int;
                       floydwarshall: bool = true): int {....raises: [], tags: [].}

proc tspPathCostFromTo[T](dist: openArray[seq[T]]; start_v, goal_v: int;
                          zero, inf: T; floydwarshall: bool = true): T