sig
  type ('a, 'b, 'c, 'd, 'e) t
  val create : int -> 'a -> ('b, 'c, 'd, 'e, 'a) SHGraph.t
  val clear : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> unit
  val is_empty : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> bool
  val size_vertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> int
  val size_hedge : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> int
  val size_edgevh : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> int
  val size_edgehv : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> int
  val size : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> int * int * int * int
  val attrvertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'c
  val attrhedge : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'b -> 'd
  val info : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'e
  val is_vertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> bool
  val is_hedge : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'b -> bool
  val succhedge : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'b Sette.t
  val predhedge : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'b Sette.t
  val succvertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'b -> 'a array
  val predvertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'b -> 'a array
  val succ_vertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a Sette.t
  val pred_vertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a Sette.t
  val add_vertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'c -> unit
  val add_hedge :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    'b -> 'd -> pred:'a array -> succ:'a array -> unit
  val remove_vertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> unit
  val remove_hedge : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'b -> unit
  val iter_vertex :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('a -> 'c -> pred:'b Sette.t -> succ:'b Sette.t -> unit) -> unit
  val iter_hedge :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('b -> 'd -> pred:'a array -> succ:'a array -> unit) -> unit
  val fold_vertex :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('a -> 'c -> pred:'b Sette.t -> succ:'b Sette.t -> 'f -> 'f) -> 'f -> 'f
  val fold_hedge :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('b -> 'd -> pred:'a array -> succ:'a array -> 'f -> 'f) -> 'f -> 'f
  val map :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('a -> 'c -> pred:'b Sette.t -> succ:'b Sette.t -> 'f) ->
    ('b -> 'd -> pred:'a array -> succ:'a array -> 'g) ->
    ('e -> 'h) -> ('a, 'b, 'f, 'g, 'h) SHGraph.t
  val copy :
    ('a -> 'b -> 'c) ->
    ('d -> 'e -> 'f) ->
    ('g -> 'h) ->
    ('a, 'd, 'b, 'e, 'g) SHGraph.t -> ('a, 'd, 'c, 'f, 'h) SHGraph.t
  val transpose :
    ('a -> 'b -> 'c) ->
    ('d -> 'e -> 'f) ->
    ('g -> 'h) ->
    ('a, 'd, 'b, 'e, 'g) SHGraph.t -> ('a, 'd, 'c, 'f, 'h) SHGraph.t
  val min : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t
  val max : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t
  val topological_sort : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a list
  val topological_sort_multi :
    'a -> 'b -> ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a list
  val topological_sort_filter_multi :
    'a ->
    'b ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> ('b -> bool) -> 'a Sette.t -> 'a list
  val reachable :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a Sette.t * 'b Sette.t
  val reachable_multi :
    'a ->
    'b ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a Sette.t * 'b Sette.t
  val reachable_filter_multi :
    'a ->
    'b ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('b -> bool) -> 'a Sette.t -> 'a Sette.t * 'b Sette.t
  val cfc : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a list list
  val cfc_multi :
    'a -> 'b -> ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a list list
  val cfc_filter_multi :
    'a ->
    'b ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('b -> bool) -> 'a Sette.t -> 'a list list
  val cfc_priority_multi :
    'a ->
    'b ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('b -> int) -> 'a Sette.t -> 'a list list
  val scfc : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a Ilist.t
  val scfc_multi :
    'a -> 'b -> ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a Ilist.t
  val scfc_filter_multi :
    'a ->
    'b ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('b -> bool) -> 'a Sette.t -> 'a Ilist.t
  val scfc_priority_multi :
    'a ->
    'b ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> ('b -> int) -> 'a Sette.t -> 'a Ilist.t
  val print :
    (Format.formatter -> 'a -> unit) ->
    (Format.formatter -> 'b -> unit) ->
    (Format.formatter -> 'c -> unit) ->
    (Format.formatter -> 'd -> unit) ->
    (Format.formatter -> 'e -> unit) ->
    Format.formatter -> ('a, 'b, 'c, 'd, 'e) SHGraph.t -> unit
  val print_dot :
    ?titlestyle:string ->
    ?vertexstyle:string ->
    ?hedgestyle:string ->
    ?title:string ->
    (Format.formatter -> 'a -> unit) ->
    (Format.formatter -> 'b -> unit) ->
    (Format.formatter -> 'a -> 'c -> unit) ->
    (Format.formatter -> 'b -> 'd -> unit) ->
    Format.formatter -> ('a, 'b, 'c, 'd, 'e) SHGraph.t -> unit
  val escaped : ?linebreak:char -> string -> string
  module type T =
    sig
      type vertex
      type hedge
      val vertex_dummy : SHGraph.T.vertex
      val hedge_dummy : SHGraph.T.hedge
      module SetV :
        sig
          type elt = vertex
          type 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 = hedge
          type 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 HashV :
        sig
          type key = vertex
          type 'a t
          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 = hedge
          type 'a t
          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
    end
  module type S =
    sig
      type vertex
      type hedge
      module SetV :
        sig
          type elt = vertex
          type 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 = hedge
          type 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) SHGraph.S.t
      val clear : ('a, 'b, 'c) SHGraph.S.t -> unit
      val is_empty : ('a, 'b, 'c) SHGraph.S.t -> bool
      val size_vertex : ('a, 'b, 'c) SHGraph.S.t -> int
      val size_hedge : ('a, 'b, 'c) SHGraph.S.t -> int
      val size_edgevh : ('a, 'b, 'c) SHGraph.S.t -> int
      val size_edgehv : ('a, 'b, 'c) SHGraph.S.t -> int
      val size : ('a, 'b, 'c) SHGraph.S.t -> int * int * int * int
      val attrvertex : ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> 'a
      val attrhedge : ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.hedge -> 'b
      val info : ('a, 'b, 'c) SHGraph.S.t -> 'c
      val is_vertex : ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> bool
      val is_hedge : ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.hedge -> bool
      val succhedge :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> SHGraph.S.SetH.t
      val predhedge :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> SHGraph.S.SetH.t
      val succvertex :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.hedge -> SHGraph.S.vertex array
      val predvertex :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.hedge -> SHGraph.S.vertex array
      val succ_vertex :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> SHGraph.S.SetV.t
      val pred_vertex :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> SHGraph.S.SetV.t
      val add_vertex :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> 'a -> unit
      val add_hedge :
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.hedge ->
        'b ->
        pred:SHGraph.S.vertex array -> succ:SHGraph.S.vertex array -> unit
      val remove_vertex :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> unit
      val remove_hedge : ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.hedge -> unit
      val iter_vertex :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.vertex ->
         'a -> pred:SHGraph.S.SetH.t -> succ:SHGraph.S.SetH.t -> unit) ->
        unit
      val iter_hedge :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge ->
         'b ->
         pred:SHGraph.S.vertex array -> succ:SHGraph.S.vertex array -> unit) ->
        unit
      val fold_vertex :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.vertex ->
         'a -> pred:SHGraph.S.SetH.t -> succ:SHGraph.S.SetH.t -> 'd -> 'd) ->
        'd -> 'd
      val fold_hedge :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge ->
         'b ->
         pred:SHGraph.S.vertex array ->
         succ:SHGraph.S.vertex array -> 'd -> 'd) ->
        'd -> 'd
      val map :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.vertex ->
         'a -> pred:SHGraph.S.SetH.t -> succ:SHGraph.S.SetH.t -> 'd) ->
        (SHGraph.S.hedge ->
         'b ->
         pred:SHGraph.S.vertex array -> succ:SHGraph.S.vertex array -> 'e) ->
        ('c -> 'f) -> ('d, 'e, 'f) SHGraph.S.t
      val copy :
        (SHGraph.S.vertex -> 'a -> 'b) ->
        (SHGraph.S.hedge -> 'c -> 'd) ->
        ('e -> 'f) -> ('a, 'c, 'e) SHGraph.S.t -> ('b, 'd, 'f) SHGraph.S.t
      val transpose :
        (SHGraph.S.vertex -> 'a -> 'b) ->
        (SHGraph.S.hedge -> 'c -> 'd) ->
        ('e -> 'f) -> ('a, 'c, 'e) SHGraph.S.t -> ('b, 'd, 'f) SHGraph.S.t
      val min : ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.SetV.t
      val max : ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.SetV.t
      val topological_sort :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> SHGraph.S.vertex list
      val topological_sort_multi :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.SetV.t -> SHGraph.S.vertex list
      val topological_sort_filter_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge -> bool) ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex list
      val reachable :
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.vertex -> SHGraph.S.SetV.t * SHGraph.S.SetH.t
      val reachable_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.SetV.t -> SHGraph.S.SetV.t * SHGraph.S.SetH.t
      val reachable_filter_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge -> bool) ->
        SHGraph.S.SetV.t -> SHGraph.S.SetV.t * SHGraph.S.SetH.t
      val cfc :
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.vertex -> SHGraph.S.vertex list list
      val cfc_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex list list
      val cfc_filter_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge -> bool) ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex list list
      val cfc_priority_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge -> int) ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex list list
      val scfc :
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.vertex -> SHGraph.S.vertex Ilist.t
      val scfc_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex Ilist.t
      val scfc_filter_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge -> bool) ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex Ilist.t
      val scfc_priority_multi :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge -> int) ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex Ilist.t
      val print :
        (Format.formatter -> SHGraph.S.vertex -> unit) ->
        (Format.formatter -> SHGraph.S.hedge -> unit) ->
        (Format.formatter -> 'a -> unit) ->
        (Format.formatter -> 'b -> unit) ->
        (Format.formatter -> 'c -> unit) ->
        Format.formatter -> ('a, 'b, 'c) SHGraph.S.t -> unit
      val print_dot :
        ?titlestyle:string ->
        ?vertexstyle:string ->
        ?hedgestyle:string ->
        ?title:string ->
        (Format.formatter -> SHGraph.S.vertex -> unit) ->
        (Format.formatter -> SHGraph.S.hedge -> unit) ->
        (Format.formatter -> SHGraph.S.vertex -> 'a -> unit) ->
        (Format.formatter -> SHGraph.S.hedge -> 'b -> unit) ->
        Format.formatter -> ('a, 'b, 'c) SHGraph.S.t -> unit
    end
  module Make :
    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
end