sig
  module Digraph :
    sig
      module Concrete :
        functor (V : Graph.Sig.COMPARABLE->
          sig
            module V :
              sig
                type t = V.t
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
                type label = t
                val label : '-> 'a
                val create : '-> 'a
              end
            module HM :
              sig
                type 'a return = 'PMAP(V).return
                type 'a t = 'PMAP(V).t
                type key = V.t
                val create : ?size:int -> unit -> 'a t
                val create_from : 'a t -> 'a t
                val empty : 'a return
                val clear : 'a t -> unit
                val is_empty : 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val find : key -> 'a t -> 'a
                val find_and_raise : key -> 'a t -> string -> 'a
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val copy : 'a t -> 'a t
              end
            module S :
              sig
                type elt = V.t
                type t = Set.Make(V).t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
              end
            module E :
              sig
                type vertex = V.t
                type t = V.t * V.t
                val compare : t -> t -> int
                val src : 'a * '-> 'a
                val dst : 'a * '-> 'b
                type label = unit
                val label : '-> unit
                val create : '-> unit -> '-> 'a * 'b
              end
            type edge = E.t
            val mem_edge : S.t HM.t -> HM.key -> S.elt -> bool
            val mem_edge_e : S.t HM.t -> HM.key * S.elt -> bool
            val find_edge : S.t HM.t -> HM.key -> S.elt -> HM.key * S.elt
            val find_all_edges :
              S.t HM.t -> HM.key -> S.elt -> (HM.key * S.elt) list
            val unsafe_remove_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
            val unsafe_remove_edge_e : S.t HM.t -> HM.key * S.elt -> S.t HM.t
            val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
            val remove_edge_e : S.t HM.t -> HM.key * HM.key -> S.t HM.t
            val iter_succ : (S.elt -> unit) -> S.t HM.t -> HM.key -> unit
            val fold_succ :
              (S.elt -> '-> 'a) -> S.t HM.t -> HM.key -> '-> 'a
            val iter_succ_e :
              (HM.key * S.elt -> unit) -> S.t HM.t -> HM.key -> unit
            val fold_succ_e :
              (HM.key * S.elt -> '-> 'a) -> S.t HM.t -> HM.key -> '-> 'a
            val succ : S.t HM.t -> HM.key -> S.elt list
            val succ_e : S.t HM.t -> HM.key -> (HM.key * S.elt) list
            val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
            module I :
              sig
                type t = S.t HM.t
                module PV :
                  sig
                    type t = V.t
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                  end
                module PE = E
                val iter_edges :
                  (HM.key -> S.elt -> unit) -> S.t HM.t -> unit
                val fold_edges :
                  (HM.key -> S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
                val iter_edges_e :
                  (HM.key * S.elt -> unit) -> S.t HM.t -> unit
                val fold_edges_e :
                  (HM.key * S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
              end
            type t = S.t HM.t
            module PV = I.PV
            module PE = I.PE
            val iter_edges : (HM.key -> S.elt -> unit) -> S.t HM.t -> unit
            val fold_edges :
              (HM.key -> S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
            val iter_edges_e : (HM.key * S.elt -> unit) -> S.t HM.t -> unit
            val fold_edges_e :
              (HM.key * S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
            val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
            val fold_pred : (V.t -> '-> 'a) -> S.t HM.t -> V.t -> '-> 'a
            val pred : S.t HM.t -> V.t -> V.t list
            val in_degree : S.t HM.t -> V.t -> int
            val iter_pred_e : (V.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
            val fold_pred_e :
              (V.t * V.t -> '-> 'a) -> S.t HM.t -> V.t -> '-> 'a
            val pred_e : S.t HM.t -> V.t -> (V.t * V.t) list
            type vertex = HM.key
            val is_directed : bool
            val empty : 'HM.return
            val create : ?size:int -> unit -> 'HM.t
            val is_empty : 'HM.t -> bool
            val copy : 'HM.t -> 'HM.t
            val clear : 'HM.t -> unit
            val nb_vertex : 'HM.t -> int
            val nb_edges : S.t HM.t -> int
            val out_degree : S.t HM.t -> HM.key -> int
            val mem_vertex : 'HM.t -> HM.key -> bool
            val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
            val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
            val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
            val iter_vertex : (HM.key -> unit) -> 'HM.t -> unit
            val fold_vertex : (HM.key -> '-> 'a) -> 'HM.t -> '-> 'a
            val add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
            val add_edge_e : S.t HM.t -> HM.key * S.elt -> S.t HM.t
          end
      module ConcreteBidirectional :
        functor (V : Graph.Sig.COMPARABLE->
          sig
            module V :
              sig
                type t = V.t
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
                type label = t
                val label : '-> 'a
                val create : '-> 'a
              end
            module HM :
              sig
                type 'a return = 'PMAP(V).return
                type 'a t = 'PMAP(V).t
                type key = V.t
                val create : ?size:int -> unit -> 'a t
                val create_from : 'a t -> 'a t
                val empty : 'a return
                val clear : 'a t -> unit
                val is_empty : 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val find : key -> 'a t -> 'a
                val find_and_raise : key -> 'a t -> string -> 'a
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val copy : 'a t -> 'a t
              end
            module S :
              sig
                type elt = V.t
                type t = Set.Make(V).t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
              end
            module E :
              sig
                type vertex = V.t
                type t = V.t * V.t
                val compare : t -> t -> int
                val src : 'a * '-> 'a
                val dst : 'a * '-> 'b
                type label = unit
                val label : '-> unit
                val create : '-> unit -> '-> 'a * 'b
              end
            type edge = E.t
            val mem_edge : ('a * S.t) HM.t -> HM.key -> S.elt -> bool
            val mem_edge_e : ('a * S.t) HM.t -> HM.key * S.elt -> bool
            val find_edge :
              ('a * S.t) HM.t -> HM.key -> S.elt -> HM.key * S.elt
            val find_all_edges :
              ('a * S.t) HM.t -> HM.key -> S.elt -> (HM.key * S.elt) list
            val unsafe_remove_edge :
              (S.t * S.t) HM.t -> HM.key -> S.elt -> (S.t * S.t) HM.t
            val unsafe_remove_edge_e :
              (S.t * S.t) HM.t -> HM.key * S.elt -> (S.t * S.t) HM.t
            val remove_edge :
              (S.t * S.t) HM.t -> HM.key -> HM.key -> (S.t * S.t) HM.t
            val remove_edge_e :
              (S.t * S.t) HM.t -> HM.key * HM.key -> (S.t * S.t) HM.t
            val iter_succ :
              (S.elt -> unit) -> ('a * S.t) HM.t -> HM.key -> unit
            val fold_succ :
              (S.elt -> '-> 'a) -> ('b * S.t) HM.t -> HM.key -> '-> 'a
            val iter_succ_e :
              (HM.key * S.elt -> unit) -> ('a * S.t) HM.t -> HM.key -> unit
            val fold_succ_e :
              (HM.key * S.elt -> '-> 'a) ->
              ('b * S.t) HM.t -> HM.key -> '-> 'a
            val succ : ('a * S.t) HM.t -> HM.key -> S.elt list
            val succ_e : ('a * S.t) HM.t -> HM.key -> (HM.key * S.elt) list
            val map_vertex :
              (HM.key -> HM.key) -> (S.t * S.t) HM.t -> (S.t * S.t) HM.t
            module I :
              sig
                type t = (S.t * S.t) HM.t
                module PV :
                  sig
                    type t = V.t
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                  end
                module PE = E
                val iter_edges :
                  (HM.key -> S.elt -> unit) -> ('a * S.t) HM.t -> unit
                val fold_edges :
                  (HM.key -> S.elt -> '-> 'a) ->
                  ('b * S.t) HM.t -> '-> 'a
                val iter_edges_e :
                  (HM.key * S.elt -> unit) -> ('a * S.t) HM.t -> unit
                val fold_edges_e :
                  (HM.key * S.elt -> '-> 'a) -> ('b * S.t) HM.t -> '-> 'a
              end
            type t = (S.t * S.t) HM.t
            module PV = I.PV
            module PE = I.PE
            val iter_edges :
              (HM.key -> S.elt -> unit) -> ('a * S.t) HM.t -> unit
            val fold_edges :
              (HM.key -> S.elt -> '-> 'a) -> ('b * S.t) HM.t -> '-> 'a
            val iter_edges_e :
              (HM.key * S.elt -> unit) -> ('a * S.t) HM.t -> unit
            val fold_edges_e :
              (HM.key * S.elt -> '-> 'a) -> ('b * S.t) HM.t -> '-> 'a
            val iter_pred :
              (S.elt -> unit) -> (S.t * 'a) HM.t -> HM.key -> unit
            val fold_pred :
              (S.elt -> '-> 'a) -> (S.t * 'b) HM.t -> HM.key -> '-> 'a
            val pred : (S.t * 'a) HM.t -> HM.key -> S.elt list
            val in_degree : (S.t * 'a) HM.t -> HM.key -> int
            val iter_pred_e :
              (S.elt * HM.key -> unit) -> (S.t * 'a) HM.t -> HM.key -> unit
            val fold_pred_e :
              (S.elt * HM.key -> '-> 'a) ->
              (S.t * 'b) HM.t -> HM.key -> '-> 'a
            val pred_e : (S.t * 'a) HM.t -> HM.key -> (S.elt * HM.key) list
            type vertex = HM.key
            val is_directed : bool
            val empty : 'HM.return
            val create : ?size:int -> unit -> 'HM.t
            val clear : 'HM.t -> unit
            val is_empty : 'HM.t -> bool
            val copy : 'HM.t -> 'HM.t
            val nb_vertex : 'HM.t -> int
            val nb_edges : ('a * S.t) HM.t -> int
            val out_degree : ('a * S.t) HM.t -> HM.key -> int
            val mem_vertex : 'HM.t -> HM.key -> bool
            val unsafe_add_vertex :
              (S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
            val add_vertex : (S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
            val iter_vertex : (HM.key -> unit) -> 'HM.t -> unit
            val fold_vertex : (HM.key -> '-> 'a) -> 'HM.t -> '-> 'a
            val unsafe_add_edge :
              (S.t * S.t) HM.t -> HM.key -> S.elt -> (S.t * S.t) HM.t
            val add_edge :
              (S.t * S.t) HM.t -> HM.key -> S.elt -> (S.t * S.t) HM.t
            val add_edge_e :
              (S.t * S.t) HM.t -> HM.key * S.elt -> (S.t * S.t) HM.t
          end
      module ConcreteLabeled :
        functor
          (V : Graph.Sig.COMPARABLE) (Edge : Graph.Sig.ORDERED_TYPE_DFT->
          sig
            module V :
              sig
                type t = V.t
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
                type label = t
                val label : '-> 'a
                val create : '-> 'a
              end
            module HM :
              sig
                type 'a return = 'PMAP(V).return
                type 'a t = 'PMAP(V).t
                type key = V.t
                val create : ?size:int -> unit -> 'a t
                val create_from : 'a t -> 'a t
                val empty : 'a return
                val clear : 'a t -> unit
                val is_empty : 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val find : key -> 'a t -> 'a
                val find_and_raise : key -> 'a t -> string -> 'a
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val copy : 'a t -> 'a t
              end
            module VE :
              sig type t = V.t * Edge.t val compare : t -> t -> int end
            module S :
              sig
                type elt = VE.t
                type t = Set.Make(VE).t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
              end
            module E :
              sig
                type vertex = V.t
                type label = Edge.t
                type t = vertex * label * vertex
                val src : 'a * 'b * '-> 'a
                val dst : 'a * 'b * '-> 'c
                val label : 'a * 'b * '-> 'b
                val create : '-> '-> '-> 'a * 'b * 'c
                module C :
                  sig type t = V.t * VE.t val compare : t -> t -> int end
                val compare : V.t * Edge.t * V.t -> V.t * Edge.t * V.t -> int
              end
            type edge = E.t
            val mem_edge : S.t HM.t -> HM.key -> V.t -> bool
            val mem_edge_e : S.t HM.t -> HM.key * Edge.t * V.t -> bool
            exception Found of edge
            val find_edge : S.t HM.t -> E.vertex -> V.t -> edge
            val find_all_edges :
              S.t HM.t -> HM.key -> V.t -> (HM.key * Edge.t * V.t) list
            val unsafe_remove_edge : S.t HM.t -> HM.key -> V.t -> S.t HM.t
            val unsafe_remove_edge_e :
              S.t HM.t -> HM.key * Edge.t * V.t -> S.t HM.t
            val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
            val remove_edge_e :
              S.t HM.t -> HM.key * Edge.t * HM.key -> S.t HM.t
            val iter_succ : (V.t -> unit) -> S.t HM.t -> HM.key -> unit
            val fold_succ :
              (V.t -> '-> 'a) -> S.t HM.t -> HM.key -> '-> 'a
            val iter_succ_e :
              (HM.key * Edge.t * V.t -> unit) -> S.t HM.t -> HM.key -> unit
            val fold_succ_e :
              (HM.key * Edge.t * V.t -> '-> 'a) ->
              S.t HM.t -> HM.key -> '-> 'a
            val succ : S.t HM.t -> HM.key -> V.t list
            val succ_e : S.t HM.t -> HM.key -> (HM.key * Edge.t * V.t) list
            val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
            module I :
              sig
                type t = S.t HM.t
                module PV :
                  sig
                    type t = V.t
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                  end
                module PE = E
                val iter_edges : (HM.key -> V.t -> unit) -> S.t HM.t -> unit
                val fold_edges :
                  (HM.key -> V.t -> '-> 'a) -> S.t HM.t -> '-> 'a
                val iter_edges_e :
                  (HM.key * Edge.t * V.t -> unit) -> S.t HM.t -> unit
                val fold_edges_e :
                  (HM.key * Edge.t * V.t -> '-> 'a) -> S.t HM.t -> '-> 'a
              end
            type t = S.t HM.t
            module PV = I.PV
            module PE = I.PE
            val iter_edges : (HM.key -> V.t -> unit) -> S.t HM.t -> unit
            val fold_edges :
              (HM.key -> V.t -> '-> 'a) -> S.t HM.t -> '-> 'a
            val iter_edges_e :
              (HM.key * Edge.t * V.t -> unit) -> S.t HM.t -> unit
            val fold_edges_e :
              (HM.key * Edge.t * V.t -> '-> 'a) -> S.t HM.t -> '-> 'a
            val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
            val fold_pred : (V.t -> '-> 'a) -> S.t HM.t -> V.t -> '-> 'a
            val pred : S.t HM.t -> V.t -> V.t list
            val in_degree : S.t HM.t -> V.t -> int
            val iter_pred_e :
              (V.t * Edge.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
            val fold_pred_e :
              (V.t * Edge.t * V.t -> '-> 'a) -> S.t HM.t -> V.t -> '-> 'a
            val pred_e : S.t HM.t -> V.t -> (V.t * Edge.t * V.t) list
            type vertex = HM.key
            val is_directed : bool
            val empty : 'HM.return
            val create : ?size:int -> unit -> 'HM.t
            val is_empty : 'HM.t -> bool
            val copy : 'HM.t -> 'HM.t
            val clear : 'HM.t -> unit
            val nb_vertex : 'HM.t -> int
            val nb_edges : S.t HM.t -> int
            val out_degree : S.t HM.t -> HM.key -> int
            val mem_vertex : 'HM.t -> HM.key -> bool
            val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
            val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
            val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
            val iter_vertex : (HM.key -> unit) -> 'HM.t -> unit
            val fold_vertex : (HM.key -> '-> 'a) -> 'HM.t -> '-> 'a
            val add_edge_e : S.t HM.t -> HM.key * Edge.t * V.t -> S.t HM.t
            val add_edge : S.t HM.t -> HM.key -> V.t -> S.t HM.t
          end
      module ConcreteBidirectionalLabeled :
        functor
          (V : Graph.Sig.COMPARABLE) (Edge : Graph.Sig.ORDERED_TYPE_DFT->
          sig
            module V :
              sig
                type t = V.t
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
                type label = t
                val label : '-> 'a
                val create : '-> 'a
              end
            module HM :
              sig
                type 'a return = 'PMAP(V).return
                type 'a t = 'PMAP(V).t
                type key = V.t
                val create : ?size:int -> unit -> 'a t
                val create_from : 'a t -> 'a t
                val empty : 'a return
                val clear : 'a t -> unit
                val is_empty : 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val find : key -> 'a t -> 'a
                val find_and_raise : key -> 'a t -> string -> 'a
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val copy : 'a t -> 'a t
              end
            module VE :
              sig type t = V.t * Edge.t val compare : t -> t -> int end
            module S :
              sig
                type elt = VE.t
                type t = Set.Make(VE).t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
              end
            module E :
              sig
                type vertex = V.t
                type label = Edge.t
                type t = vertex * label * vertex
                val src : 'a * 'b * '-> 'a
                val dst : 'a * 'b * '-> 'c
                val label : 'a * 'b * '-> 'b
                val create : '-> '-> '-> 'a * 'b * 'c
                module C :
                  sig type t = V.t * VE.t val compare : t -> t -> int end
                val compare : V.t * Edge.t * V.t -> V.t * Edge.t * V.t -> int
              end
            type edge = E.t
            val mem_edge : ('a * S.t) HM.t -> HM.key -> V.t -> bool
            val mem_edge_e : ('a * S.t) HM.t -> HM.key * Edge.t * V.t -> bool
            exception Found of edge
            val find_edge : ('a * S.t) HM.t -> E.vertex -> V.t -> edge
            val find_all_edges :
              ('a * S.t) HM.t ->
              HM.key -> V.t -> (HM.key * Edge.t * V.t) list
            val unsafe_remove_edge :
              (S.t * S.t) HM.t -> HM.key -> HM.key -> (S.t * S.t) HM.t
            val unsafe_remove_edge_e :
              (S.t * S.t) HM.t ->
              HM.key * Edge.t * HM.key -> (S.t * S.t) HM.t
            val remove_edge :
              (S.t * S.t) HM.t -> HM.key -> HM.key -> (S.t * S.t) HM.t
            val remove_edge_e :
              (S.t * S.t) HM.t ->
              HM.key * Edge.t * HM.key -> (S.t * S.t) HM.t
            val iter_succ :
              (V.t -> unit) -> ('a * S.t) HM.t -> HM.key -> unit
            val fold_succ :
              (V.t -> '-> 'a) -> ('b * S.t) HM.t -> HM.key -> '-> 'a
            val iter_succ_e :
              (HM.key * Edge.t * V.t -> unit) ->
              ('a * S.t) HM.t -> HM.key -> unit
            val fold_succ_e :
              (HM.key * Edge.t * V.t -> '-> 'a) ->
              ('b * S.t) HM.t -> HM.key -> '-> 'a
            val succ : ('a * S.t) HM.t -> HM.key -> V.t list
            val succ_e :
              ('a * S.t) HM.t -> HM.key -> (HM.key * Edge.t * V.t) list
            val map_vertex :
              (HM.key -> HM.key) -> (S.t * S.t) HM.t -> (S.t * S.t) HM.t
            module I :
              sig
                type t = (S.t * S.t) HM.t
                module PV :
                  sig
                    type t = V.t
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                  end
                module PE = E
                val iter_edges :
                  (HM.key -> V.t -> unit) -> ('a * S.t) HM.t -> unit
                val fold_edges :
                  (HM.key -> V.t -> '-> 'a) -> ('b * S.t) HM.t -> '-> 'a
                val iter_edges_e :
                  (HM.key * Edge.t * V.t -> unit) -> ('a * S.t) HM.t -> unit
                val fold_edges_e :
                  (HM.key * Edge.t * V.t -> '-> 'a) ->
                  ('b * S.t) HM.t -> '-> 'a
              end
            type t = (S.t * S.t) HM.t
            module PV = I.PV
            module PE = I.PE
            val iter_edges :
              (HM.key -> V.t -> unit) -> ('a * S.t) HM.t -> unit
            val fold_edges :
              (HM.key -> V.t -> '-> 'a) -> ('b * S.t) HM.t -> '-> 'a
            val iter_edges_e :
              (HM.key * Edge.t * V.t -> unit) -> ('a * S.t) HM.t -> unit
            val fold_edges_e :
              (HM.key * Edge.t * V.t -> '-> 'a) ->
              ('b * S.t) HM.t -> '-> 'a
            val iter_pred :
              (V.t -> unit) -> (S.t * 'a) HM.t -> HM.key -> unit
            val fold_pred :
              (V.t -> '-> 'a) -> (S.t * 'b) HM.t -> HM.key -> '-> 'a
            val in_degree : (S.t * 'a) HM.t -> HM.key -> int
            val iter_pred_e :
              (V.t * Edge.t * HM.key -> unit) ->
              (S.t * 'a) HM.t -> HM.key -> unit
            val fold_pred_e :
              (V.t * Edge.t * HM.key -> '-> 'a) ->
              (S.t * 'b) HM.t -> HM.key -> '-> 'a
            val pred : (S.t * 'a) HM.t -> HM.key -> V.t list
            val pred_e :
              (S.t * 'a) HM.t -> HM.key -> (V.t * Edge.t * HM.key) list
            type vertex = HM.key
            val is_directed : bool
            val empty : 'HM.return
            val create : ?size:int -> unit -> 'HM.t
            val clear : 'HM.t -> unit
            val is_empty : 'HM.t -> bool
            val copy : 'HM.t -> 'HM.t
            val nb_vertex : 'HM.t -> int
            val nb_edges : ('a * S.t) HM.t -> int
            val out_degree : ('a * S.t) HM.t -> HM.key -> int
            val mem_vertex : 'HM.t -> HM.key -> bool
            val unsafe_add_vertex :
              (S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
            val add_vertex : (S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
            val iter_vertex : (HM.key -> unit) -> 'HM.t -> unit
            val fold_vertex : (HM.key -> '-> 'a) -> 'HM.t -> '-> 'a
            val unsafe_add_edge_e :
              (S.t * S.t) HM.t -> HM.key * Edge.t * V.t -> (S.t * S.t) HM.t
            val add_edge_e :
              (S.t * S.t) HM.t -> HM.key * Edge.t * V.t -> (S.t * S.t) HM.t
            val add_edge :
              (S.t * S.t) HM.t -> HM.key -> V.t -> (S.t * S.t) HM.t
          end
      module Abstract :
        functor (V : Graph.Sig.VERTEX->
          sig
            module G :
              sig
                module V :
                  sig
                    type t = V.t
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                    type label = V.label
                    val create : label -> t
                    val label : t -> label
                  end
                module HM :
                  sig
                    type 'a return = 'PMAP(V).return
                    type 'a t = 'PMAP(V).t
                    type key = V.t
                    val create : ?size:int -> unit -> 'a t
                    val create_from : 'a t -> 'a t
                    val empty : 'a return
                    val clear : 'a t -> unit
                    val is_empty : 'a t -> bool
                    val add : key -> '-> 'a t -> 'a t
                    val remove : key -> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val find : key -> 'a t -> 'a
                    val find_and_raise : key -> 'a t -> string -> 'a
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val copy : 'a t -> 'a t
                  end
                module S :
                  sig
                    type elt = V.t
                    type t = Set.Make(V).t
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val split : elt -> t -> t * bool * t
                    val find : elt -> t -> elt
                    val of_list : elt list -> t
                  end
                module E :
                  sig
                    type vertex = V.t
                    type t = V.t * V.t
                    val compare : t -> t -> int
                    val src : 'a * '-> 'a
                    val dst : 'a * '-> 'b
                    type label = unit
                    val label : '-> unit
                    val create : '-> unit -> '-> 'a * 'b
                  end
                type edge = E.t
                val mem_edge : S.t HM.t -> HM.key -> S.elt -> bool
                val mem_edge_e : S.t HM.t -> HM.key * S.elt -> bool
                val find_edge : S.t HM.t -> HM.key -> S.elt -> HM.key * S.elt
                val find_all_edges :
                  S.t HM.t -> HM.key -> S.elt -> (HM.key * S.elt) list
                val unsafe_remove_edge :
                  S.t HM.t -> HM.key -> S.elt -> S.t HM.t
                val unsafe_remove_edge_e :
                  S.t HM.t -> HM.key * S.elt -> S.t HM.t
                val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
                val remove_edge_e : S.t HM.t -> HM.key * HM.key -> S.t HM.t
                val iter_succ : (S.elt -> unit) -> S.t HM.t -> HM.key -> unit
                val fold_succ :
                  (S.elt -> '-> 'a) -> S.t HM.t -> HM.key -> '-> 'a
                val iter_succ_e :
                  (HM.key * S.elt -> unit) -> S.t HM.t -> HM.key -> unit
                val fold_succ_e :
                  (HM.key * S.elt -> '-> 'a) ->
                  S.t HM.t -> HM.key -> '-> 'a
                val succ : S.t HM.t -> HM.key -> S.elt list
                val succ_e : S.t HM.t -> HM.key -> (HM.key * S.elt) list
                val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
                module I :
                  sig
                    type t = S.t HM.t
                    module PV :
                      sig
                        type t = V.t
                        val compare : t -> t -> int
                        val hash : t -> int
                        val equal : t -> t -> bool
                      end
                    module PE = E
                    val iter_edges :
                      (HM.key -> S.elt -> unit) -> S.t HM.t -> unit
                    val fold_edges :
                      (HM.key -> S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
                    val iter_edges_e :
                      (HM.key * S.elt -> unit) -> S.t HM.t -> unit
                    val fold_edges_e :
                      (HM.key * S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
                  end
                type t = S.t HM.t
                module PV = I.PV
                module PE = I.PE
                val iter_edges :
                  (HM.key -> S.elt -> unit) -> S.t HM.t -> unit
                val fold_edges :
                  (HM.key -> S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
                val iter_edges_e :
                  (HM.key * S.elt -> unit) -> S.t HM.t -> unit
                val fold_edges_e :
                  (HM.key * S.elt -> '-> 'a) -> S.t HM.t -> '-> 'a
                val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
                val fold_pred :
                  (V.t -> '-> 'a) -> S.t HM.t -> V.t -> '-> 'a
                val pred : S.t HM.t -> V.t -> V.t list
                val in_degree : S.t HM.t -> V.t -> int
                val iter_pred_e :
                  (V.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
                val fold_pred_e :
                  (V.t * V.t -> '-> 'a) -> S.t HM.t -> V.t -> '-> 'a
                val pred_e : S.t HM.t -> V.t -> (V.t * V.t) list
                type vertex = HM.key
                val is_directed : bool
                val empty : 'HM.return
                val create : ?size:int -> unit -> 'HM.t
                val is_empty : 'HM.t -> bool
                val copy : 'HM.t -> 'HM.t
                val clear : 'HM.t -> unit
                val nb_vertex : 'HM.t -> int
                val nb_edges : S.t HM.t -> int
                val out_degree : S.t HM.t -> HM.key -> int
                val mem_vertex : 'HM.t -> HM.key -> bool
                val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
                val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
                val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
                val iter_vertex : (HM.key -> unit) -> 'HM.t -> unit
                val fold_vertex : (HM.key -> '-> 'a) -> 'HM.t -> '-> 'a
              end
            module I :
              sig
                type t =
                  Graph.Blocks.Make_Abstract(G).I.t = {
                  edges : G.t;
                  mutable size : int;
                }
                type vertex = G.vertex
                type edge = G.edge
                module PV :
                  sig
                    type t = G.HM.key
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                    type label = G.V.label
                    val create : label -> t
                    val label : t -> label
                  end
                module PE :
                  sig
                    type t = G.E.t
                    val compare : t -> t -> int
                    type vertex = G.vertex
                    val src : t -> vertex
                    val dst : t -> vertex
                    type label = G.E.label
                    val create : vertex -> label -> vertex -> t
                    val label : t -> label
                  end
                val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
                val fold_edges :
                  (G.vertex -> G.vertex -> '-> 'a) -> t -> '-> 'a
                val iter_edges_e : (G.edge -> unit) -> t -> unit
                val fold_edges_e : (G.edge -> '-> 'a) -> t -> '-> 'a
                val mem_vertex : G.vertex -> t -> bool
                val create : ?size:int -> unit -> t
                val clear : t -> unit
              end
            type t = I.t = { edges : G.t; mutable size : int; }
            type vertex = G.vertex
            type edge = G.edge
            module PV = I.PV
            module PE = I.PE
            val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
            val fold_edges :
              (G.vertex -> G.vertex -> '-> 'a) -> t -> '-> 'a
            val iter_edges_e : (G.edge -> unit) -> t -> unit
            val fold_edges_e : (G.edge -> '-> 'a) -> t -> '-> 'a
            val create : ?size:int -> unit -> t
            val clear : t -> unit
            val iter_pred : (I.PV.t -> unit) -> I.t -> I.PV.t -> unit
            val fold_pred : (I.PV.t -> '-> 'a) -> I.t -> I.PV.t -> '-> 'a
            val pred : I.t -> I.PV.t -> I.PV.t list
            val iter_pred_e : (I.PE.t -> unit) -> I.t -> I.PV.t -> unit
            val fold_pred_e :
              (I.PE.t -> '-> 'a) -> I.t -> I.PV.t -> '-> 'a
            val pred_e : I.t -> I.PV.t -> I.PE.t list
            val is_empty : t -> bool
            val nb_vertex : t -> int
            module V :
              sig
                type t = G.HM.key
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
                type label = G.V.label
                val create : label -> t
                val label : t -> label
              end
            module E :
              sig
                type t = G.E.t
                val compare : t -> t -> int
                type vertex = G.vertex
                val src : t -> vertex
                val dst : t -> vertex
                type label = G.E.label
                val create : vertex -> label -> vertex -> t
                val label : t -> label
              end
            module HM :
              sig
                type 'a return = 'G.HM.return
                type 'a t = 'G.HM.t
                type key = G.HM.key
                val create : ?size:int -> unit -> 'a t
                val create_from : 'a t -> 'a t
                val empty : 'a return
                val clear : 'a t -> unit
                val is_empty : 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val find : key -> 'a t -> 'a
                val find_and_raise : key -> 'a t -> string -> 'a
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val copy : 'a t -> 'a t
              end
            module S :
              sig
                type elt = G.S.elt
                type t = G.S.t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
              end
            val unsafe_add_edge : G.t -> G.vertex -> G.S.elt -> G.t
            val unsafe_remove_edge : G.t -> G.vertex -> G.vertex -> G.t
            val unsafe_remove_edge_e : G.t -> G.edge -> G.t
            val is_directed : bool
            val remove_edge : t -> G.vertex -> G.vertex -> G.t
            val remove_edge_e : t -> G.edge -> G.t
            val out_degree : t -> G.vertex -> int
            val in_degree : t -> G.vertex -> int
            val nb_edges : t -> int
            val succ : t -> G.vertex -> G.vertex list
            val mem_vertex : t -> G.vertex -> bool
            val mem_edge : t -> G.vertex -> G.vertex -> bool
            val mem_edge_e : t -> G.edge -> bool
            val find_edge : t -> G.vertex -> G.vertex -> G.edge
            val find_all_edges : t -> G.vertex -> G.vertex -> G.edge list
            val iter_vertex : (G.vertex -> unit) -> t -> unit
            val fold_vertex : (G.vertex -> '-> 'a) -> t -> '-> 'a
            val iter_succ : (G.vertex -> unit) -> t -> G.vertex -> unit
            val fold_succ :
              (G.vertex -> '-> 'a) -> t -> G.vertex -> '-> 'a
            val succ_e : t -> G.vertex -> G.edge list
            val iter_succ_e : (G.edge -> unit) -> t -> G.vertex -> unit
            val fold_succ_e :
              (G.edge -> '-> 'a) -> t -> G.vertex -> '-> 'a
            val map_vertex : (G.vertex -> G.vertex) -> t -> t
            val copy : t -> t
          end
      module AbstractLabeled :
        functor (V : Graph.Sig.VERTEX) (E : Graph.Sig.ORDERED_TYPE_DFT->
          sig
            module G :
              sig
                module V :
                  sig
                    type t = V.t
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                    type label = V.label
                    val create : label -> t
                    val label : t -> label
                  end
                module HM :
                  sig
                    type 'a return = 'PMAP(V).return
                    type 'a t = 'PMAP(V).t
                    type key = V.t
                    val create : ?size:int -> unit -> 'a t
                    val create_from : 'a t -> 'a t
                    val empty : 'a return
                    val clear : 'a t -> unit
                    val is_empty : 'a t -> bool
                    val add : key -> '-> 'a t -> 'a t
                    val remove : key -> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val find : key -> 'a t -> 'a
                    val find_and_raise : key -> 'a t -> string -> 'a
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val copy : 'a t -> 'a t
                  end
                module VE :
                  sig type t = V.t * E.t val compare : t -> t -> int end
                module S :
                  sig
                    type elt = VE.t
                    type t = Set.Make(VE).t
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val split : elt -> t -> t * bool * t
                    val find : elt -> t -> elt
                    val of_list : elt list -> t
                  end
                module E :
                  sig
                    type vertex = V.t
                    type label = E.t
                    type t = vertex * label * vertex
                    val src : 'a * 'b * '-> 'a
                    val dst : 'a * 'b * '-> 'c
                    val label : 'a * 'b * '-> 'b
                    val create : '-> '-> '-> 'a * 'b * 'c
                    module C :
                      sig type t = V.t * VE.t val compare : t -> t -> int end
                    val compare : V.t * E.t * V.t -> V.t * E.t * V.t -> int
                  end
                type edge = E.t
                val mem_edge : S.t HM.t -> HM.key -> V.t -> bool
                val mem_edge_e : S.t HM.t -> HM.key * E.t * V.t -> bool
                exception Found of edge
                val find_edge : S.t HM.t -> E.vertex -> V.t -> edge
                val find_all_edges :
                  S.t HM.t -> HM.key -> V.t -> (HM.key * E.t * V.t) list
                val unsafe_remove_edge :
                  S.t HM.t -> HM.key -> V.t -> S.t HM.t
                val unsafe_remove_edge_e :
                  S.t HM.t -> HM.key * E.t * V.t -> S.t HM.t
                val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
                val remove_edge_e :
                  S.t HM.t -> HM.key * E.t * HM.key -> S.t HM.t
                val iter_succ : (V.t -> unit) -> S.t HM.t -> HM.key -> unit
                val fold_succ :
                  (V.t -> '-> 'a) -> S.t HM.t -> HM.key -> '-> 'a
                val iter_succ_e :
                  (HM.key * E.t * V.t -> unit) -> S.t HM.t -> HM.key -> unit
                val fold_succ_e :
                  (HM.key * E.t * V.t -> '-> 'a) ->
                  S.t HM.t -> HM.key -> '-> 'a
                val succ : S.t HM.t -> HM.key -> V.t list
                val succ_e : S.t HM.t -> HM.key -> (HM.key * E.t * V.t) list
                val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
                module I :
                  sig
                    type t = S.t HM.t
                    module PV :
                      sig
                        type t = V.t
                        val compare : t -> t -> int
                        val hash : t -> int
                        val equal : t -> t -> bool
                      end
                    module PE = E
                    val iter_edges :
                      (HM.key -> V.t -> unit) -> S.t HM.t -> unit
                    val fold_edges :
                      (HM.key -> V.t -> '-> 'a) -> S.t HM.t -> '-> 'a
                    val iter_edges_e :
                      (HM.key * E.t * V.t -> unit) -> S.t HM.t -> unit
                    val fold_edges_e :
                      (HM.key * E.t * V.t -> '-> 'a) ->
                      S.t HM.t -> '-> 'a
                  end
                type t = S.t HM.t
                module PV = I.PV
                module PE = I.PE
                val iter_edges : (HM.key -> V.t -> unit) -> S.t HM.t -> unit
                val fold_edges :
                  (HM.key -> V.t -> '-> 'a) -> S.t HM.t -> '-> 'a
                val iter_edges_e :
                  (HM.key * E.t * V.t -> unit) -> S.t HM.t -> unit
                val fold_edges_e :
                  (HM.key * E.t * V.t -> '-> 'a) -> S.t HM.t -> '-> 'a
                val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
                val fold_pred :
                  (V.t -> '-> 'a) -> S.t HM.t -> V.t -> '-> 'a
                val pred : S.t HM.t -> V.t -> V.t list
                val in_degree : S.t HM.t -> V.t -> int
                val iter_pred_e :
                  (V.t * E.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
                val fold_pred_e :
                  (V.t * E.t * V.t -> '-> 'a) ->
                  S.t HM.t -> V.t -> '-> 'a
                val pred_e : S.t HM.t -> V.t -> (V.t * E.t * V.t) list
                type vertex = HM.key
                val is_directed : bool
                val empty : 'HM.return
                val create : ?size:int -> unit -> 'HM.t
                val is_empty : 'HM.t -> bool
                val copy : 'HM.t -> 'HM.t
                val clear : 'HM.t -> unit
                val nb_vertex : 'HM.t -> int
                val nb_edges : S.t HM.t -> int
                val out_degree : S.t HM.t -> HM.key -> int
                val mem_vertex : 'HM.t -> HM.key -> bool
                val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
                val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
                val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
                val iter_vertex : (HM.key -> unit) -> 'HM.t -> unit
                val fold_vertex : (HM.key -> '-> 'a) -> 'HM.t -> '-> 'a
              end
            module I :
              sig
                type t =
                  Graph.Blocks.Make_Abstract(G).I.t = {
                  edges : G.t;
                  mutable size : int;
                }
                type vertex = G.vertex
                type edge = G.edge
                module PV :
                  sig
                    type t = G.HM.key
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                    type label = G.V.label
                    val create : label -> t
                    val label : t -> label
                  end
                module PE :
                  sig
                    type t = G.E.t
                    val compare : t -> t -> int
                    type vertex = G.vertex
                    val src : t -> vertex
                    val dst : t -> vertex
                    type label = G.E.label
                    val create : vertex -> label -> vertex -> t
                    val label : t -> label
                  end
                val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
                val fold_edges :
                  (G.vertex -> G.vertex -> '-> 'a) -> t -> '-> 'a
                val iter_edges_e : (G.edge -> unit) -> t -> unit
                val fold_edges_e : (G.edge -> '-> 'a) -> t -> '-> 'a
                val mem_vertex : G.vertex -> t -> bool
                val create : ?size:int -> unit -> t
                val clear : t -> unit
              end
            type t = I.t = { edges : G.t; mutable size : int; }
            type vertex = G.vertex
            type edge = G.edge
            module PV = I.PV
            module PE = I.PE
            val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
            val fold_edges :
              (G.vertex -> G.vertex -> '-> 'a) -> t -> '-> 'a
            val iter_edges_e : (G.edge -> unit) -> t -> unit
            val fold_edges_e : (G.edge -> '-> 'a) -> t -> '-> 'a
            val create : ?size:int -> unit -> t
            val clear : t -> unit
            val iter_pred : (I.PV.t -> unit) -> I.t -> I.PV.t -> unit
            val fold_pred : (I.PV.t -> '-> 'a) -> I.t -> I.PV.t -> '-> 'a
            val pred : I.t -> I.PV.t -> I.PV.t list
            val iter_pred_e : (I.PE.t -> unit) -> I.t -> I.PV.t -> unit
            val fold_pred_e :
              (I.PE.t -> '-> 'a) -> I.t -> I.PV.t -> '-> 'a
            val pred_e : I.t -> I.PV.t -> I.PE.t list
            val is_empty : t -> bool
            val nb_vertex : t -> int
            module V :
              sig
                type t = G.HM.key
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
                type label = G.V.label
                val create : label -> t
                val label : t -> label
              end
            module E :
              sig
                type t = G.E.t
                val compare : t -> t -> int
                type vertex = G.vertex
                val src : t -> vertex
                val dst : t -> vertex
                type label = G.E.label
                val create : vertex -> label -> vertex -> t
                val label : t -> label
              end
            module HM :
              sig
                type 'a return = 'G.HM.return
                type 'a t = 'G.HM.t
                type key = G.HM.key
                val create : ?size:int -> unit -> 'a t
                val create_from : 'a t -> 'a t
                val empty : 'a return
                val clear : 'a t -> unit
                val is_empty : 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val find : key -> 'a t -> 'a
                val find_and_raise : key -> 'a t -> string -> 'a
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : (key -> '-> key * 'a) -> 'a t -> 'a t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val copy : 'a t -> 'a t
              end
            module S :
              sig
                type elt = G.S.elt
                type t = G.S.t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
              end
            val unsafe_add_edge : G.t -> G.vertex -> G.S.elt -> G.t
            val unsafe_remove_edge : G.t -> G.vertex -> G.vertex -> G.t
            val unsafe_remove_edge_e : G.t -> G.edge -> G.t
            val is_directed : bool
            val remove_edge : t -> G.vertex -> G.vertex -> G.t
            val remove_edge_e : t -> G.edge -> G.t
            val out_degree : t -> G.vertex -> int
            val in_degree : t -> G.vertex -> int
            val nb_edges : t -> int
            val succ : t -> G.vertex -> G.vertex list
            val mem_vertex : t -> G.vertex -> bool
            val mem_edge : t -> G.vertex -> G.vertex -> bool
            val mem_edge_e : t -> G.edge -> bool
            val find_edge : t -> G.vertex -> G.vertex -> G.edge
            val find_all_edges : t -> G.vertex -> G.vertex -> G.edge list
            val iter_vertex : (G.vertex -> unit) -> t -> unit
            val fold_vertex : (G.vertex -> '-> 'a) -> t -> '-> 'a
            val iter_succ : (G.vertex -> unit) -> t -> G.vertex -> unit
            val fold_succ :
              (G.vertex -> '-> 'a) -> t -> G.vertex -> '-> 'a
            val succ_e : t -> G.vertex -> G.edge list
            val iter_succ_e : (G.edge -> unit) -> t -> G.vertex -> unit
            val fold_succ_e :
              (G.edge -> '-> 'a) -> t -> G.vertex -> '-> 'a
            val map_vertex : (G.vertex -> G.vertex) -> t -> t
            val copy : t -> t
          end
    end
end