functor (T : T->
  sig
    type vertex = T.MapV.key
    module SetV :
      sig
        type elt = T.MapV.key
        type t = T.MapV.Setkey.t
        val repr : t -> elt Sette.set
        val obj : elt Sette.set -> t
        module Ord : sig type t = elt val compare : t -> t -> int end
        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 print :
          ?first:(unit, Format.formatter, unit) format ->
          ?sep:(unit, Format.formatter, unit) format ->
          ?last:(unit, Format.formatter, unit) format ->
          (Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit
      end
    module SetE :
      sig
        type elt = T.MapE.key
        type t = T.MapE.Setkey.t
        val repr : t -> elt Sette.set
        val obj : elt Sette.set -> t
        module Ord : sig type t = elt val compare : t -> t -> int end
        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 print :
          ?first:(unit, Format.formatter, unit) format ->
          ?sep:(unit, Format.formatter, unit) format ->
          ?last:(unit, Format.formatter, unit) format ->
          (Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit
      end
    module MapV :
      sig
        type key = T.MapV.key
        type 'a t = 'T.MapV.t
        module Setkey :
          sig
            type elt = key
            type t = T.MapV.Setkey.t
            val repr : t -> elt Sette.set
            val obj : elt Sette.set -> t
            module Ord : sig type t = elt val compare : t -> t -> int end
            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 print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              (Format.formatter -> elt -> unit) ->
              Format.formatter -> t -> unit
          end
        val repr : 'a t -> (key, 'a) Mappe.map
        val obj : (key, 'a) Mappe.map -> 'a t
        val is_empty : 'a t -> bool
        val empty : 'a t
        val add : key -> '-> 'a t -> 'a t
        val find : key -> 'a t -> 'a
        val remove : key -> 'a t -> 'a t
        val mem : key -> 'a t -> bool
        val addmap : 'a t -> 'a t -> 'a t
        val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
        val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
        val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
        val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
        val combine :
          (key -> 'a option -> 'b option -> 'c option) ->
          'a t -> 'b t -> 'c t
        val interset : 'a t -> Setkey.t -> 'a t
        val diffset : 'a t -> Setkey.t -> 'a t
        val iter : (key -> '-> unit) -> 'a t -> unit
        val map : ('-> 'b) -> 'a t -> 'b t
        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
        val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
        val maptoset : 'a t -> Setkey.t
        val mapofset : (key -> 'a) -> Setkey.t -> 'a t
        val compare : ('-> '-> int) -> 'a t -> 'b t -> int
        val comparei : (key -> '-> '-> int) -> 'a t -> 'b t -> int
        val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
        val equali : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
        val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
        val subseti : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
        val filter : (key -> '-> bool) -> 'a t -> 'a t
        val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
        val cardinal : 'a t -> int
        val bindings : 'a t -> (key * 'a) list
        val min_key : 'a t -> key
        val max_key : 'a t -> key
        val choose : 'a t -> key * 'a
        val print :
          ?first:(unit, Format.formatter, unit) format ->
          ?sep:(unit, Format.formatter, unit) format ->
          ?last:(unit, Format.formatter, unit) format ->
          ?firstbind:(unit, Format.formatter, unit) format ->
          ?sepbind:(unit, Format.formatter, unit) format ->
          ?lastbind:(unit, Format.formatter, unit) format ->
          (Format.formatter -> key -> unit) ->
          (Format.formatter -> '-> unit) ->
          Format.formatter -> 'a t -> unit
      end
    module MapE :
      sig
        type key = T.MapV.key * T.MapV.key
        type 'a t = 'T.MapE.t
        module Setkey :
          sig
            type elt = key
            type t = T.MapE.Setkey.t
            val repr : t -> elt Sette.set
            val obj : elt Sette.set -> t
            module Ord : sig type t = elt val compare : t -> t -> int end
            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 print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              (Format.formatter -> elt -> unit) ->
              Format.formatter -> t -> unit
          end
        val repr : 'a t -> (key, 'a) Mappe.map
        val obj : (key, 'a) Mappe.map -> 'a t
        val is_empty : 'a t -> bool
        val empty : 'a t
        val add : key -> '-> 'a t -> 'a t
        val find : key -> 'a t -> 'a
        val remove : key -> 'a t -> 'a t
        val mem : key -> 'a t -> bool
        val addmap : 'a t -> 'a t -> 'a t
        val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
        val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
        val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
        val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
        val combine :
          (key -> 'a option -> 'b option -> 'c option) ->
          'a t -> 'b t -> 'c t
        val interset : 'a t -> Setkey.t -> 'a t
        val diffset : 'a t -> Setkey.t -> 'a t
        val iter : (key -> '-> unit) -> 'a t -> unit
        val map : ('-> 'b) -> 'a t -> 'b t
        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
        val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
        val maptoset : 'a t -> Setkey.t
        val mapofset : (key -> 'a) -> Setkey.t -> 'a t
        val compare : ('-> '-> int) -> 'a t -> 'b t -> int
        val comparei : (key -> '-> '-> int) -> 'a t -> 'b t -> int
        val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
        val equali : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
        val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
        val subseti : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
        val filter : (key -> '-> bool) -> 'a t -> 'a t
        val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
        val cardinal : 'a t -> int
        val bindings : 'a t -> (key * 'a) list
        val min_key : 'a t -> key
        val max_key : 'a t -> key
        val choose : 'a t -> key * 'a
        val print :
          ?first:(unit, Format.formatter, unit) format ->
          ?sep:(unit, Format.formatter, unit) format ->
          ?last:(unit, Format.formatter, unit) format ->
          ?firstbind:(unit, Format.formatter, unit) format ->
          ?sepbind:(unit, Format.formatter, unit) format ->
          ?lastbind:(unit, Format.formatter, unit) format ->
          (Format.formatter -> key -> unit) ->
          (Format.formatter -> '-> unit) ->
          Format.formatter -> 'a t -> unit
      end
    type ('a, 'b, 'c) t
    val info : ('a, 'b, 'c) t -> 'c
    val set_info : ('a, 'b, 'c) t -> '-> ('a, 'b, 'c) t
    val succ : ('a, 'b, 'c) t -> vertex -> SetV.t
    val pred : ('a, 'b, 'c) t -> vertex -> SetV.t
    val attrvertex : ('a, 'b, 'c) t -> vertex -> 'a
    val attredge : ('a, 'b, 'c) t -> vertex * vertex -> 'b
    val empty : '-> ('b, 'c, 'a) t
    val size_vertex : ('a, 'b, 'c) t -> int
    val size_edge : ('a, 'b, 'c) t -> int
    val size : ('a, 'b, 'c) t -> int * int
    val is_empty : ('a, 'b, 'c) t -> bool
    val is_vertex : ('a, 'b, 'c) t -> vertex -> bool
    val is_edge : ('a, 'b, 'c) t -> vertex * vertex -> bool
    val vertices : ('a, 'b, 'c) t -> SetV.t
    val edges : ('a, 'b, 'c) t -> SetE.t
    val map_vertex :
      ('a, 'b, 'c) t ->
      (vertex -> '-> pred:SetV.t -> succ:SetV.t -> 'd) -> ('d, 'b, 'c) t
    val map_edge :
      ('a, 'b, 'c) t -> (vertex * vertex -> '-> 'd) -> ('a, 'd, 'c) t
    val map_info : ('a, 'b, 'c) t -> ('-> 'd) -> ('a, 'b, 'd) t
    val map :
      ('a, 'b, 'c) t ->
      (vertex -> '-> pred:SetV.t -> succ:SetV.t -> 'd) ->
      (vertex * vertex -> '-> 'e) -> ('-> 'f) -> ('d, 'e, 'f) t
    val transpose :
      ('a, 'b, 'c) t ->
      (vertex -> '-> pred:SetV.t -> succ:SetV.t -> 'd) ->
      (vertex * vertex -> '-> 'e) -> ('-> 'f) -> ('d, 'e, 'f) t
    val iter_vertex :
      ('a, 'b, 'c) t ->
      (vertex -> '-> pred:SetV.t -> succ:SetV.t -> unit) -> unit
    val iter_edge : ('a, 'b, 'c) t -> (vertex * vertex -> '-> unit) -> unit
    val fold_vertex :
      ('a, 'b, 'c) t ->
      '-> (vertex -> '-> pred:SetV.t -> succ:SetV.t -> '-> 'd) -> 'd
    val fold_edge :
      ('a, 'b, 'c) t -> '-> (vertex * vertex -> '-> '-> 'd) -> 'd
    val add_edge : ('a, 'b, 'c) t -> vertex * vertex -> '-> ('a, 'b, 'c) t
    val remove_edge : ('a, 'b, 'c) t -> vertex * vertex -> ('a, 'b, 'c) t
    val add_vertex : ('a, 'b, 'c) t -> vertex -> '-> ('a, 'b, 'c) t
    val remove_vertex : ('a, 'b, 'c) t -> vertex -> ('a, 'b, 'c) t
    val topological_sort : ('a, 'b, 'c) t -> vertex -> vertex list
    val topological_sort_multi :
      vertex -> ('a, 'b, 'c) t -> SetV.t -> vertex list
    val reachable : ('a, 'b, 'c) t -> vertex -> SetV.t
    val reachable_multi : vertex -> ('a, 'b, 'c) t -> SetV.t -> SetV.t
    val coreachable : ('a, 'b, 'c) t -> vertex -> SetV.t
    val coreachable_multi : vertex -> ('a, 'b, 'c) t -> SetV.t -> SetV.t
    val cfc : ('a, 'b, 'c) t -> vertex -> vertex list list
    val cfc_multi : vertex -> ('a, 'b, 'c) t -> SetV.t -> vertex list list
    val scfc : ('a, 'b, 'c) t -> vertex -> vertex Ilist.t
    val scfc_multi : vertex -> ('a, 'b, 'c) t -> SetV.t -> vertex Ilist.t
    val min : ('a, 'b, 'c) t -> SetV.t
    val max : ('a, 'b, 'c) t -> SetV.t
    val print :
      (Format.formatter -> vertex -> unit) ->
      (Format.formatter -> '-> unit) ->
      (Format.formatter -> '-> unit) ->
      (Format.formatter -> '-> unit) ->
      Format.formatter -> ('a, 'b, 'c) t -> unit
    val print_dot :
      ?titlestyle:string ->
      ?vertexstyle:string ->
      ?edgestyle:string ->
      ?title:string ->
      (Format.formatter -> vertex -> unit) ->
      (Format.formatter -> vertex -> '-> unit) ->
      (Format.formatter -> vertex * vertex -> '-> unit) ->
      Format.formatter -> ('a, 'b, 'c) t -> unit
    val repr : ('a, 'b, 'c) t -> (vertex, 'a, 'b, 'c) graph
    val obj : (vertex, 'a, 'b, 'c) graph -> ('a, 'b, 'c) t
  end