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
              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 :
                  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
                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 :
              sig
                type t = V.t
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
              end
            module PE :
              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
            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 -> HM.key -> S.t HM.t
            val add_edge_e : S.t HM.t -> HM.key * HM.key -> 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
              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 :
                  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
                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 :
              sig
                type t = V.t
                val compare : t -> t -> int
                val hash : t -> int
                val equal : t -> t -> bool
              end
            module PE :
              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
            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 -> HM.key -> (S.t * S.t) HM.t
            val add_edge_e :
              (S.t * S.t) HM.t -> HM.key * HM.key -> (S.t * S.t) HM.t
          end
      module ConcreteLabeled :
        functor (V : Graph.Sig.COMPARABLE->
          functor (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
                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 :
                    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
                  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 :
                sig
                  type t = V.t
                  val compare : t -> t -> int
                  val hash : t -> int
                  val equal : t -> t -> bool
                end
              module PE :
                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
              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 * HM.key -> S.t HM.t
              val add_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
            end
      module ConcreteBidirectionalLabeled :
        functor (V : Graph.Sig.COMPARABLE->
          functor (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
                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 :
                    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
                  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 :
                sig
                  type t = V.t
                  val compare : t -> t -> int
                  val hash : t -> int
                  val equal : t -> t -> bool
                end
              module PE :
                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
              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 unsafe_add_edge :
                (S.t * S.t) HM.t -> HM.key -> V.t -> (S.t * S.t) HM.t
              val add_edge_e :
                (S.t * S.t) HM.t ->
                HM.key * Edge.t * HM.key -> (S.t * S.t) HM.t
              val add_edge :
                (S.t * S.t) HM.t -> HM.key -> HM.key -> (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
                  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 :
                      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
                    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 :
                  sig
                    type t = V.t
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                  end
                module PE :
                  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
                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 :
              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 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
              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->
          functor (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
                    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 :
                        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
                      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 :
                    sig
                      type t = V.t
                      val compare : t -> t -> int
                      val hash : t -> int
                      val equal : t -> t -> bool
                    end
                  module PE :
                    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
                  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 :
                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 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
                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