functor (T : T) ->
  sig
    type vertex = T.vertex
    type hedge = T.hedge
    module SetV :
      sig
        type elt = T.vertex
        type t = T.SetV.t
        module Ord : sig type t = elt val compare : t -> t -> int end
        val repr : t -> elt Sette.tzz
        val obj : elt Sette.tzz -> t
        val splitzz :
          elt -> elt Sette.tzz -> elt Sette.tzz * bool * elt Sette.tzz
        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
        module Ord : sig type t = elt val compare : t -> t -> int end
        val repr : t -> elt Sette.tzz
        val obj : elt Sette.tzz -> t
        val splitzz :
          elt -> elt Sette.tzz -> elt Sette.tzz * bool * elt Sette.tzz
        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
    type ('a, 'b, 'c) t
    val create : int -> 'a -> ('b, 'c, 'a) 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 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 -> 'd -> 'd) -> 'd -> 'd
    val fold_hedge :
      ('a, 'b, 'c) t ->
      (hedge -> 'b -> pred:vertex array -> succ:vertex array -> 'd -> 'd) ->
      'd -> 'd
    val map :
      ('a, 'b, 'c) t ->
      (vertex -> 'a -> pred:SetH.t -> succ:SetH.t -> 'd) ->
      (hedge -> 'b -> pred:vertex array -> succ:vertex array -> 'e) ->
      ('c -> 'f) -> ('d, 'e, 'f) t
    val copy :
      (vertex -> 'a -> 'b) ->
      (hedge -> 'c -> 'd) -> ('e -> 'f) -> ('a, 'c, 'e) t -> ('b, 'd, 'f) t
    val transpose :
      (vertex -> 'a -> 'b) ->
      (hedge -> 'c -> 'd) -> ('e -> 'f) -> ('a, 'c, 'e) t -> ('b, 'd, 'f) t
    val min : ('a, 'b, 'c) t -> SetV.t
    val max : ('a, 'b, 'c) t -> SetV.t
    val topological_sort : ('a, 'b, 'c) t -> vertex -> vertex list
    val topological_sort_multi : ('a, 'b, 'c) t -> SetV.t -> vertex list
    val topological_sort_filter_multi :
      ('a, 'b, 'c) t -> (hedge -> bool) -> SetV.t -> vertex list
    val reachable : ('a, 'b, 'c) t -> vertex -> SetV.t * SetH.t
    val reachable_multi : ('a, 'b, 'c) t -> SetV.t -> SetV.t * SetH.t
    val reachable_filter_multi :
      ('a, 'b, 'c) t -> (hedge -> bool) -> SetV.t -> SetV.t * SetH.t
    val cfc : ('a, 'b, 'c) t -> vertex -> vertex list list
    val cfc_multi : ('a, 'b, 'c) t -> SetV.t -> vertex list list
    val cfc_filter_multi :
      ('a, 'b, 'c) t -> (hedge -> bool) -> SetV.t -> vertex list list
    val cfc_priority_multi :
      ('a, 'b, 'c) t -> (hedge -> int) -> SetV.t -> vertex list list
    val scfc : ('a, 'b, 'c) t -> vertex -> vertex Ilist.t
    val scfc_multi : ('a, 'b, 'c) t -> SetV.t -> vertex Ilist.t
    val scfc_filter_multi :
      ('a, 'b, 'c) t -> (hedge -> bool) -> SetV.t -> vertex Ilist.t
    val scfc_priority_multi :
      ('a, 'b, 'c) t -> (hedge -> int) -> SetV.t -> 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 :
      ?titlestyle:string ->
      ?vertexstyle:string ->
      ?hedgestyle: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