functor (T : T) ->
  sig
    type vertex = T.vertex
    type hedge = T.hedge
    val vertex_dummy : vertex
    val hedge_dummy : hedge
    module SetV :
      sig
        type elt = T.vertex
        type t = 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
    module SetH :
      sig
        type elt = T.hedge
        type t = T.SetH.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 HashV :
      sig
        type key = T.vertex
        type 'a t = (key, 'a) Hashhe.hashtbl
        module Hash :
          sig type t = key val equal : t -> t -> bool val hash : t -> int end
        val create : int -> 'a t
        val clear : 'a t -> unit
        val copy : 'a t -> 'a t
        val add : 'a t -> key -> 'a -> unit
        val remove : 'a t -> key -> unit
        val find : 'a t -> key -> 'a
        val find_all : 'a t -> key -> 'a list
        val replace : 'a t -> key -> 'a -> unit
        val mem : 'a t -> key -> bool
        val iter : (key -> 'a -> unit) -> 'a t -> unit
        val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
        val map : (key -> 'a -> 'b) -> 'a t -> 'b t
        val length : 'a t -> int
        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 HashH :
      sig
        type key = T.hedge
        type 'a t = (key, 'a) Hashhe.hashtbl
        module Hash :
          sig type t = key val equal : t -> t -> bool val hash : t -> int end
        val create : int -> 'a t
        val clear : 'a t -> unit
        val copy : 'a t -> 'a t
        val add : 'a t -> key -> 'a -> unit
        val remove : 'a t -> key -> unit
        val find : 'a t -> key -> 'a
        val find_all : 'a t -> key -> 'a list
        val replace : 'a t -> key -> 'a -> unit
        val mem : 'a t -> key -> bool
        val iter : (key -> 'a -> unit) -> 'a t -> unit
        val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
        val map : (key -> 'a -> 'b) -> 'a t -> 'b t
        val length : 'a t -> int
        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
    val stdcompare : (vertex, hedge) compare
    type ('a, 'b, 'c) t
    val create : int -> 'c -> ('a, 'b, 'c) t
    val clear : ('a, 'b, 'c) t -> unit
    val is_empty : ('a, 'b, 'c) t -> bool
    val size_vertex : ('a, 'b, 'c) t -> int
    val size_hedge : ('a, 'b, 'c) t -> int
    val size_edgevh : ('a, 'b, 'c) t -> int
    val size_edgehv : ('a, 'b, 'c) t -> int
    val size : ('a, 'b, 'c) t -> int * int * int * int
    val attrvertex : ('a, 'b, 'c) t -> vertex -> 'a
    val attrhedge : ('a, 'b, 'c) t -> hedge -> 'b
    val info : ('a, 'b, 'c) t -> 'c
    val is_vertex : ('a, 'b, 'c) t -> vertex -> bool
    val is_hedge : ('a, 'b, 'c) t -> hedge -> bool
    val succhedge : ('a, 'b, 'c) t -> vertex -> SetH.t
    val predhedge : ('a, 'b, 'c) t -> vertex -> SetH.t
    val succvertex : ('a, 'b, 'c) t -> hedge -> vertex array
    val predvertex : ('a, 'b, 'c) t -> hedge -> vertex array
    val succ_vertex : ('a, 'b, 'c) t -> vertex -> SetV.t
    val pred_vertex : ('a, 'b, 'c) t -> vertex -> SetV.t
    val add_vertex : ('a, 'b, 'c) t -> vertex -> 'a -> unit
    val add_hedge :
      ('a, 'b, 'c) t ->
      hedge -> 'b -> pred:vertex array -> succ:vertex array -> unit
    val replace_attrvertex : ('a, 'b, 'c) t -> vertex -> 'a -> unit
    val replace_attrhedge : ('a, 'b, 'c) t -> hedge -> 'b -> unit
    val remove_vertex : ('a, 'b, 'c) t -> vertex -> unit
    val remove_hedge : ('a, 'b, 'c) t -> hedge -> unit
    val iter_vertex :
      ('a, 'b, 'c) t ->
      (vertex -> 'a -> pred:SetH.t -> succ:SetH.t -> unit) -> unit
    val iter_hedge :
      ('a, 'b, 'c) t ->
      (hedge -> 'b -> pred:vertex array -> succ:vertex array -> unit) -> unit
    val fold_vertex :
      ('a, 'b, 'c) t ->
      (vertex -> 'a -> pred:SetH.t -> succ:SetH.t -> 'g -> 'g) -> 'g -> 'g
    val fold_hedge :
      ('a, 'b, 'c) t ->
      (hedge -> 'b -> pred:vertex array -> succ:vertex array -> 'g -> 'g) ->
      'g -> 'g
    val map :
      ('a, 'b, 'c) t ->
      (vertex -> 'a -> 'aa) ->
      (hedge -> 'b -> 'bb) -> ('c -> 'cc) -> ('aa, 'bb, 'cc) t
    val copy :
      (vertex -> 'a -> 'aa) ->
      (hedge -> 'b -> 'bb) ->
      ('c -> 'cc) -> ('a, 'b, 'c) t -> ('aa, 'bb, 'cc) t
    val transpose :
      (vertex -> 'a -> 'aa) ->
      (hedge -> 'b -> 'bb) ->
      ('c -> 'cc) -> ('a, 'b, 'c) t -> ('aa, 'bb, 'cc) t
    val min : ('a, 'b, 'c) t -> SetV.t
    val max : ('a, 'b, 'c) t -> SetV.t
    val topological_sort :
      ?priority:hedge priority -> ('a, 'b, 'c) t -> vertex -> vertex list
    val topological_sort_multi :
      ?priority:hedge priority -> ('a, 'b, 'c) t -> SetV.t -> vertex list
    val reachable :
      ?filter:(hedge -> bool) -> ('a, 'b, 'c) t -> vertex -> SetV.t * SetH.t
    val reachable_multi :
      ?filter:(hedge -> bool) -> ('a, 'b, 'c) t -> SetV.t -> SetV.t * SetH.t
    val cfc :
      ?priority:hedge priority ->
      ('a, 'b, 'c) t -> vertex -> vertex list list
    val cfc_multi :
      ?priority:hedge priority ->
      ('a, 'b, 'c) t -> SetV.t -> vertex list list
    val scfc :
      ?priority:hedge priority ->
      ('a, 'b, 'c) t -> vertex -> (unit, vertex) Ilist.t
    val scfc_multi :
      ?priority:hedge priority ->
      ('a, 'b, 'c) t -> SetV.t -> (unit, vertex) Ilist.t
    val print :
      (Format.formatter -> vertex -> unit) ->
      (Format.formatter -> hedge -> unit) ->
      (Format.formatter -> 'a -> unit) ->
      (Format.formatter -> 'b -> unit) ->
      (Format.formatter -> 'c -> unit) ->
      Format.formatter -> ('a, 'b, 'c) t -> unit
    val print_dot :
      ?style:string ->
      ?titlestyle:string ->
      ?vertexstyle:string ->
      ?hedgestyle:string ->
      ?fvertexstyle:(vertex -> string) ->
      ?fhedgestyle:(hedge -> string) ->
      ?title:string ->
      (Format.formatter -> vertex -> unit) ->
      (Format.formatter -> hedge -> unit) ->
      (Format.formatter -> vertex -> 'a -> unit) ->
      (Format.formatter -> hedge -> 'b -> unit) ->
      Format.formatter -> ('a, 'b, 'c) t -> unit
  end