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 ('b, 'c, 'd) t
    val info : ('b, 'c, 'd) t -> 'd
    val set_info : ('b, 'c, 'd) t -> '-> ('b, 'c, 'd) t
    val succ : ('b, 'c, 'd) t -> vertex -> SetV.t
    val pred : ('b, 'c, 'd) t -> vertex -> SetV.t
    val attrvertex : ('b, 'c, 'd) t -> vertex -> 'b
    val attredge : ('b, 'c, 'd) t -> vertex * vertex -> 'c
    val empty : '-> ('b, 'c, 'd) t
    val size : ('b, 'c, 'd) t -> int
    val is_empty : ('b, 'c, 'd) t -> bool
    val is_vertex : ('b, 'c, 'd) t -> vertex -> bool
    val is_edge : ('b, 'c, 'd) t -> vertex * vertex -> bool
    val vertices : ('b, 'c, 'd) t -> SetV.t
    val edges : ('b, 'c, 'd) t -> SetE.t
    val map_vertex : ('b, 'c, 'd) t -> (vertex -> '-> 'e) -> ('e, 'c, 'd) t
    val map_edge :
      ('b, 'c, 'd) t -> (vertex * vertex -> '-> 'e) -> ('b, 'e, 'd) t
    val map_info : ('b, 'c, 'd) t -> ('-> 'e) -> ('b, 'c, 'e) t
    val map :
      ('b, 'c, 'd) t ->
      (vertex -> '-> 'bb) ->
      (vertex * vertex -> '-> 'cc) -> ('-> 'dd) -> ('bb, 'cc, 'dd) t
    val iter_vertex :
      ('b, 'c, 'd) t -> (vertex -> '-> SetV.t -> unit) -> unit
    val iter_edge : ('b, 'c, 'd) t -> (vertex * vertex -> '-> unit) -> unit
    val fold_vertex :
      ('b, 'c, 'd) t -> '-> (vertex -> '-> SetV.t -> '-> 'e) -> 'e
    val fold_edge :
      ('b, 'c, 'd) t -> '-> (vertex * vertex -> '-> '-> 'e) -> 'e
    val add_edge : ('b, 'c, 'd) t -> vertex * vertex -> '-> ('b, 'c, 'd) t
    val remove_edge : ('b, 'c, 'd) t -> vertex * vertex -> ('b, 'c, 'd) t
    val add_vertex : ('b, 'c, 'd) t -> vertex -> '-> ('b, 'c, 'd) t
    val remove_vertex : ('b, 'c, 'd) t -> vertex -> ('b, 'c, 'd) t
    val topological_sort : ('b, 'c, 'd) t -> vertex -> vertex list
    val topological_sort_multi :
      vertex -> ('b, 'c, 'd) t -> SetV.t -> vertex list
    val reachable : ('b, 'c, 'd) t -> vertex -> SetV.t
    val reachable_multi : vertex -> ('b, 'c, 'd) t -> SetV.t -> SetV.t
    val cfc : ('b, 'c, 'd) t -> vertex -> vertex list list
    val cfc_multi : vertex -> ('b, 'c, 'd) t -> SetV.t -> vertex list list
    val scfc : ('b, 'c, 'd) t -> vertex -> (unit, vertex) Ilist.t
    val scfc_multi :
      vertex -> ('b, 'c, 'd) t -> SetV.t -> (unit, vertex) Ilist.t
    val min : ('b, 'c, 'd) t -> SetV.t
    val max : ('b, 'c, 'd) t -> SetV.t
    val print :
      (Format.formatter -> vertex -> unit) ->
      (Format.formatter -> '-> unit) ->
      (Format.formatter -> '-> unit) ->
      (Format.formatter -> '-> unit) ->
      Format.formatter -> ('b, 'c, 'd) t -> unit
  end