sig
  type ('a, 'b) node = {
    succ : 'a Sette.t;
    pred : 'a Sette.t;
    attrvertex : 'b;
  }
  type ('a, 'b, 'c, 'd) graph = {
    nodes : ('a, ('a, 'b) FGraph.node) Mappe.t;
    arcs : ('a * 'a, 'c) Mappe.t;
    info : 'd;
  }
  type ('a, 'b, 'c, 'd) t
  val info : ('a, 'b, 'c, 'd) FGraph.t -> 'd
  val set_info : ('a, 'b, 'c, 'd) FGraph.t -> 'd -> ('a, 'b, 'c, 'd) FGraph.t
  val succ : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'a Sette.t
  val pred : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'a Sette.t
  val attrvertex : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'b
  val attredge : ('a, 'b, 'c, 'd) FGraph.t -> 'a * 'a -> 'c
  val empty : 'd -> ('a, 'b, 'c, 'd) FGraph.t
  val size_vertex : ('a, 'b, 'c, 'd) FGraph.t -> int
  val size_edge : ('a, 'b, 'c, 'd) FGraph.t -> int
  val size : ('a, 'b, 'c, 'd) FGraph.t -> int * int
  val is_empty : ('a, 'b, 'c, 'd) FGraph.t -> bool
  val is_vertex : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> bool
  val is_edge : ('a, 'b, 'c, 'd) FGraph.t -> 'a * 'a -> bool
  val vertices : ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t
  val edges : ('a, 'b, 'c, 'd) FGraph.t -> ('a * 'a) Sette.t
  val map_vertex :
    ('a, 'b, 'c, 'd) FGraph.t ->
    ('a -> 'b -> pred:'a Sette.t -> succ:'a Sette.t -> 'e) ->
    ('a, 'e, 'c, 'd) FGraph.t
  val map_edge :
    ('a, 'b, 'c, 'd) FGraph.t ->
    ('a * 'a -> 'c -> 'e) -> ('a, 'b, 'e, 'd) FGraph.t
  val map_info :
    ('a, 'b, 'c, 'd) FGraph.t -> ('d -> 'e) -> ('a, 'b, 'c, 'e) FGraph.t
  val map :
    ('a, 'b, 'c, 'd) FGraph.t ->
    ('a -> 'b -> pred:'a Sette.t -> succ:'a Sette.t -> 'bb) ->
    ('a * 'a -> 'c -> 'cc) -> ('d -> 'dd) -> ('a, 'bb, 'cc, 'dd) FGraph.t
  val transpose :
    ('a, 'b, 'c, 'd) FGraph.t ->
    ('a -> 'b -> pred:'a Sette.t -> succ:'a Sette.t -> 'bb) ->
    ('a * 'a -> 'c -> 'cc) -> ('d -> 'dd) -> ('a, 'bb, 'cc, 'dd) FGraph.t
  val iter_vertex :
    ('a, 'b, 'c, 'd) FGraph.t ->
    ('a -> 'b -> pred:'a Sette.t -> succ:'a Sette.t -> unit) -> unit
  val iter_edge :
    ('a, 'b, 'c, 'd) FGraph.t -> ('a * 'a -> 'c -> unit) -> unit
  val fold_vertex :
    ('a, 'b, 'c, 'd) FGraph.t ->
    'e -> ('a -> 'b -> pred:'a Sette.t -> succ:'a Sette.t -> 'e -> 'e) -> 'e
  val fold_edge :
    ('a, 'b, 'c, 'd) FGraph.t -> 'e -> ('a * 'a -> 'c -> 'e -> 'e) -> 'e
  val add_edge :
    ('a, 'b, 'c, 'd) FGraph.t -> 'a * 'a -> 'c -> ('a, 'b, 'c, 'd) FGraph.t
  val remove_edge :
    ('a, 'b, 'c, 'd) FGraph.t -> 'a * 'a -> ('a, 'b, 'c, 'd) FGraph.t
  val add_vertex :
    ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'b -> ('a, 'b, 'c, 'd) FGraph.t
  val remove_vertex :
    ('a, 'b, 'c, 'd) FGraph.t -> 'a -> ('a, 'b, 'c, 'd) FGraph.t
  val topological_sort : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'a list
  val topological_sort_multi :
    'a -> ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t -> 'a list
  val reachable : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'a Sette.t
  val reachable_multi :
    'a -> ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t -> 'a Sette.t
  val coreachable : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'a Sette.t
  val coreachable_multi :
    'a -> ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t -> 'a Sette.t
  val cfc : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> 'a list list
  val cfc_multi :
    'a -> ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t -> 'a list list
  val scfc : ('a, 'b, 'c, 'd) FGraph.t -> 'a -> (unit, 'a) Ilist.t
  val scfc_multi :
    'a -> ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t -> (unit, 'a) Ilist.t
  val min : ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t
  val max : ('a, 'b, 'c, 'd) FGraph.t -> 'a Sette.t
  val print :
    (Format.formatter -> 'a -> unit) ->
    (Format.formatter -> 'b -> unit) ->
    (Format.formatter -> 'c -> unit) ->
    (Format.formatter -> 'd -> unit) ->
    Format.formatter -> ('a, 'b, 'c, 'd) FGraph.t -> unit
  val print_dot :
    ?titlestyle:string ->
    ?vertexstyle:string ->
    ?edgestyle:string ->
    ?title:string ->
    (Format.formatter -> 'a -> unit) ->
    (Format.formatter -> 'a -> 'b -> unit) ->
    (Format.formatter -> 'a * 'a -> 'c -> unit) ->
    Format.formatter -> ('a, 'b, 'c, 'd) FGraph.t -> unit
  val repr : ('a, 'b, 'c, 'd) FGraph.t -> ('a, 'b, 'c, 'd) FGraph.graph
  val obj : ('a, 'b, 'c, 'd) FGraph.graph -> ('a, 'b, 'c, 'd) FGraph.t
  module type T =
    sig
      module MapV : Mappe.S
      module MapE :
        sig
          type key = MapV.key * MapV.key
          type 'a t
          module Setkey :
            sig
              type elt = key
              type 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
          val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
          val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
          val commoni : (key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
          val map : ('a -> 'b) -> 'a t -> 'b t
          val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
          val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
          val maptoset : 'a t -> Setkey.t
          val mapofset : (key -> 'a) -> Setkey.t -> 'a t
          val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
          val comparei : (key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
          val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val equali : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val subseti : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val filter : (key -> 'a -> bool) -> 'a t -> 'a t
          val partition : (key -> 'a -> 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 -> 'a -> unit) ->
            Format.formatter -> 'a t -> unit
        end
    end
  module type S =
    sig
      type vertex
      module SetV :
        sig
          type elt = vertex
          type 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 -> 'a) -> t -> 'a -> '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 = vertex * vertex
          type 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 -> 'a) -> t -> 'a -> '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 = vertex
          type 'a t
          module Setkey :
            sig
              type elt = vertex
              type t = SetV.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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
          val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
          val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
          val commoni : (key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
          val map : ('a -> 'b) -> 'a t -> 'b t
          val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
          val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
          val maptoset : 'a t -> Setkey.t
          val mapofset : (key -> 'a) -> Setkey.t -> 'a t
          val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
          val comparei : (key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
          val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val equali : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val subseti : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val filter : (key -> 'a -> bool) -> 'a t -> 'a t
          val partition : (key -> 'a -> 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 -> 'a -> unit) ->
            Format.formatter -> 'a t -> unit
        end
      module MapE :
        sig
          type key = vertex * vertex
          type 'a t
          module Setkey :
            sig
              type elt = vertex * vertex
              type t = SetE.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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
          val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
          val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
          val commoni : (key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
          val map : ('a -> 'b) -> 'a t -> 'b t
          val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
          val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
          val maptoset : 'a t -> Setkey.t
          val mapofset : (key -> 'a) -> Setkey.t -> 'a t
          val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
          val comparei : (key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
          val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val equali : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val subseti : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
          val filter : (key -> 'a -> bool) -> 'a t -> 'a t
          val partition : (key -> 'a -> 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 -> 'a -> unit) ->
            Format.formatter -> 'a t -> unit
        end
      type ('b, 'c, 'd) t
      val info : ('b, 'c, 'd) FGraph.S.t -> 'd
      val set_info : ('b, 'c, 'd) FGraph.S.t -> 'd -> ('b, 'c, 'd) FGraph.S.t
      val succ :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> FGraph.S.SetV.t
      val pred :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> FGraph.S.SetV.t
      val attrvertex : ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> 'b
      val attredge :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex * FGraph.S.vertex -> 'c
      val empty : 'd -> ('b, 'c, 'd) FGraph.S.t
      val size_vertex : ('b, 'c, 'd) FGraph.S.t -> int
      val size_edge : ('b, 'c, 'd) FGraph.S.t -> int
      val size : ('b, 'c, 'd) FGraph.S.t -> int * int
      val is_empty : ('b, 'c, 'd) FGraph.S.t -> bool
      val is_vertex : ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> bool
      val is_edge :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex * FGraph.S.vertex -> bool
      val vertices : ('b, 'c, 'd) FGraph.S.t -> FGraph.S.SetV.t
      val edges : ('b, 'c, 'd) FGraph.S.t -> FGraph.S.SetE.t
      val map_vertex :
        ('b, 'c, 'd) FGraph.S.t ->
        (FGraph.S.vertex ->
         'b -> pred:FGraph.S.SetV.t -> succ:FGraph.S.SetV.t -> 'e) ->
        ('e, 'c, 'd) FGraph.S.t
      val map_edge :
        ('b, 'c, 'd) FGraph.S.t ->
        (FGraph.S.vertex * FGraph.S.vertex -> 'c -> 'e) ->
        ('b, 'e, 'd) FGraph.S.t
      val map_info :
        ('b, 'c, 'd) FGraph.S.t -> ('d -> 'e) -> ('b, 'c, 'e) FGraph.S.t
      val map :
        ('b, 'c, 'd) FGraph.S.t ->
        (FGraph.S.vertex ->
         'b -> pred:FGraph.S.SetV.t -> succ:FGraph.S.SetV.t -> 'bb) ->
        (FGraph.S.vertex * FGraph.S.vertex -> 'c -> 'cc) ->
        ('d -> 'dd) -> ('bb, 'cc, 'dd) FGraph.S.t
      val transpose :
        ('b, 'c, 'd) FGraph.S.t ->
        (FGraph.S.vertex ->
         'b -> pred:FGraph.S.SetV.t -> succ:FGraph.S.SetV.t -> 'bb) ->
        (FGraph.S.vertex * FGraph.S.vertex -> 'c -> 'cc) ->
        ('d -> 'dd) -> ('bb, 'cc, 'dd) FGraph.S.t
      val iter_vertex :
        ('b, 'c, 'd) FGraph.S.t ->
        (FGraph.S.vertex ->
         'b -> pred:FGraph.S.SetV.t -> succ:FGraph.S.SetV.t -> unit) ->
        unit
      val iter_edge :
        ('b, 'c, 'd) FGraph.S.t ->
        (FGraph.S.vertex * FGraph.S.vertex -> 'c -> unit) -> unit
      val fold_vertex :
        ('b, 'c, 'd) FGraph.S.t ->
        'e ->
        (FGraph.S.vertex ->
         'b -> pred:FGraph.S.SetV.t -> succ:FGraph.S.SetV.t -> 'e -> 'e) ->
        'e
      val fold_edge :
        ('b, 'c, 'd) FGraph.S.t ->
        'e -> (FGraph.S.vertex * FGraph.S.vertex -> 'c -> 'e -> 'e) -> 'e
      val add_edge :
        ('b, 'c, 'd) FGraph.S.t ->
        FGraph.S.vertex * FGraph.S.vertex -> 'c -> ('b, 'c, 'd) FGraph.S.t
      val remove_edge :
        ('b, 'c, 'd) FGraph.S.t ->
        FGraph.S.vertex * FGraph.S.vertex -> ('b, 'c, 'd) FGraph.S.t
      val add_vertex :
        ('b, 'c, 'd) FGraph.S.t ->
        FGraph.S.vertex -> 'b -> ('b, 'c, 'd) FGraph.S.t
      val remove_vertex :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> ('b, 'c, 'd) FGraph.S.t
      val topological_sort :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> FGraph.S.vertex list
      val topological_sort_multi :
        FGraph.S.vertex ->
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.SetV.t -> FGraph.S.vertex list
      val reachable :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> FGraph.S.SetV.t
      val reachable_multi :
        FGraph.S.vertex ->
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.SetV.t -> FGraph.S.SetV.t
      val coreachable :
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.vertex -> FGraph.S.SetV.t
      val coreachable_multi :
        FGraph.S.vertex ->
        ('b, 'c, 'd) FGraph.S.t -> FGraph.S.SetV.t -> FGraph.S.SetV.t
      val cfc :
        ('b, 'c, 'd) FGraph.S.t ->
        FGraph.S.vertex -> FGraph.S.vertex list list
      val cfc_multi :
        FGraph.S.vertex ->
        ('b, 'c, 'd) FGraph.S.t ->
        FGraph.S.SetV.t -> FGraph.S.vertex list list
      val scfc :
        ('b, 'c, 'd) FGraph.S.t ->
        FGraph.S.vertex -> (unit, FGraph.S.vertex) Ilist.t
      val scfc_multi :
        FGraph.S.vertex ->
        ('b, 'c, 'd) FGraph.S.t ->
        FGraph.S.SetV.t -> (unit, FGraph.S.vertex) Ilist.t
      val min : ('b, 'c, 'd) FGraph.S.t -> FGraph.S.SetV.t
      val max : ('b, 'c, 'd) FGraph.S.t -> FGraph.S.SetV.t
      val print :
        (Format.formatter -> FGraph.S.vertex -> unit) ->
        (Format.formatter -> 'b -> unit) ->
        (Format.formatter -> 'c -> unit) ->
        (Format.formatter -> 'd -> unit) ->
        Format.formatter -> ('b, 'c, 'd) FGraph.S.t -> unit
      val print_dot :
        ?titlestyle:string ->
        ?vertexstyle:string ->
        ?edgestyle:string ->
        ?title:string ->
        (Format.formatter -> FGraph.S.vertex -> unit) ->
        (Format.formatter -> FGraph.S.vertex -> 'b -> unit) ->
        (Format.formatter -> FGraph.S.vertex * FGraph.S.vertex -> 'c -> unit) ->
        Format.formatter -> ('b, 'c, 'd) FGraph.S.t -> unit
      val repr :
        ('b, 'c, 'd) FGraph.S.t -> (FGraph.S.vertex, 'b, 'c, 'd) FGraph.graph
      val obj :
        (FGraph.S.vertex, 'b, 'c, 'd) FGraph.graph -> ('b, 'c, 'd) FGraph.S.t
    end
  module Make :
    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 -> 'a) -> t -> 'a -> '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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
            val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
            val comparei : (key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
            val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val filter : (key -> 'a -> bool) -> 'a t -> 'a t
            val partition : (key -> 'a -> 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 -> 'a -> unit) ->
              Format.formatter -> 'a t -> unit
          end
        module MapE :
          sig
            type key = T.MapV.key * T.MapV.key
            type 'a t = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
            val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
            val comparei : (key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
            val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val filter : (key -> 'a -> bool) -> 'a t -> 'a t
            val partition : (key -> 'a -> 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 -> 'a -> 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 -> 'd -> ('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 : 'd -> ('b, 'c, 'd) t
        val size_vertex : ('b, 'c, 'd) t -> int
        val size_edge : ('b, 'c, 'd) t -> int
        val size : ('b, 'c, 'd) t -> int * 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 -> 'b -> pred:SetV.t -> succ:SetV.t -> 'e) ->
          ('e, 'c, 'd) t
        val map_edge :
          ('b, 'c, 'd) t -> (vertex * vertex -> 'c -> 'e) -> ('b, 'e, 'd) t
        val map_info : ('b, 'c, 'd) t -> ('d -> 'e) -> ('b, 'c, 'e) t
        val map :
          ('b, 'c, 'd) t ->
          (vertex -> 'b -> pred:SetV.t -> succ:SetV.t -> 'bb) ->
          (vertex * vertex -> 'c -> 'cc) -> ('d -> 'dd) -> ('bb, 'cc, 'dd) t
        val transpose :
          ('b, 'c, 'd) t ->
          (vertex -> 'b -> pred:SetV.t -> succ:SetV.t -> 'bb) ->
          (vertex * vertex -> 'c -> 'cc) -> ('d -> 'dd) -> ('bb, 'cc, 'dd) t
        val iter_vertex :
          ('b, 'c, 'd) t ->
          (vertex -> 'b -> pred:SetV.t -> succ:SetV.t -> unit) -> unit
        val iter_edge :
          ('b, 'c, 'd) t -> (vertex * vertex -> 'c -> unit) -> unit
        val fold_vertex :
          ('b, 'c, 'd) t ->
          'e ->
          (vertex -> 'b -> pred:SetV.t -> succ:SetV.t -> 'e -> 'e) -> 'e
        val fold_edge :
          ('b, 'c, 'd) t -> 'e -> (vertex * vertex -> 'c -> 'e -> 'e) -> 'e
        val add_edge :
          ('b, 'c, 'd) t -> vertex * vertex -> 'c -> ('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 -> ('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 coreachable : ('b, 'c, 'd) t -> vertex -> SetV.t
        val coreachable_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 -> 'b -> unit) ->
          (Format.formatter -> 'c -> unit) ->
          (Format.formatter -> 'd -> unit) ->
          Format.formatter -> ('b, 'c, 'd) t -> unit
        val print_dot :
          ?titlestyle:string ->
          ?vertexstyle:string ->
          ?edgestyle:string ->
          ?title:string ->
          (Format.formatter -> vertex -> unit) ->
          (Format.formatter -> vertex -> 'b -> unit) ->
          (Format.formatter -> vertex * vertex -> 'c -> unit) ->
          Format.formatter -> ('b, 'c, 'd) t -> unit
        val repr : ('b, 'c, 'd) t -> (vertex, 'b, 'c, 'd) graph
        val obj : (vertex, 'b, 'c, 'd) graph -> ('b, 'c, 'd) t
      end
end