sig
  type 'a priority = Filter of ('a -> bool) | Priority of ('a -> int)
  type ('a, 'b) compare = {
    hashv : 'a Hashhe.compare;
    hashh : 'b Hashhe.compare;
    comparev : 'a -> 'a -> int;
    compareh : 'b -> 'b -> int;
  }
  type ('b, 'c) vertex_n = {
    attrvertex : 'c;
    mutable predhedge : 'b Sette.set;
    mutable succhedge : 'b Sette.set;
  }
  type ('a, 'd) hedge_n = {
    attrhedge : 'd;
    predvertex : 'a array;
    succvertex : 'a array;
  }
  type ('a, 'b, 'c, 'd, 'e) graph = {
    vertex : ('a, ('b, 'c) SHGraph.vertex_n) Hashhe.hashtbl;
    hedge : ('b, ('a, 'd) SHGraph.hedge_n) Hashhe.hashtbl;
    info : 'e;
  }
  val stdcompare : ('a, 'b) SHGraph.compare
  type ('a, 'b, 'c, 'd, 'e) t = ('a, 'b, 'c, 'd, 'e) SHGraph.graph
  val create : int -> 'e -> ('a, 'b, 'c, 'd, 'e) 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 replace_attrvertex : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'c -> unit
  val replace_attrhedge : ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'b -> 'd -> 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 -> 'h -> 'h) -> 'h -> 'h
  val fold_hedge :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('b -> 'd -> pred:'a array -> succ:'a array -> 'h -> 'h) -> 'h -> 'h
  val map :
    ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
    ('a -> 'c -> 'cc) ->
    ('b -> 'd -> 'dd) -> ('e -> 'ee) -> ('a, 'b, 'cc, 'dd, 'ee) SHGraph.t
  val copy :
    ('a -> 'c -> 'cc) ->
    ('b -> 'd -> 'dd) ->
    ('e -> 'ee) ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> ('a, 'b, 'cc, 'dd, 'ee) SHGraph.t
  val transpose :
    ('a -> 'c -> 'cc) ->
    ('b -> 'd -> 'dd) ->
    ('e -> 'ee) ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> ('a, 'b, 'cc, 'dd, 'ee) 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 :
    ?priority:'b SHGraph.priority ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a list
  val topological_sort_multi :
    'a ->
    'b ->
    ?priority:'b SHGraph.priority ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a list
  val reachable :
    ?filter:('b -> bool) ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a Sette.t * 'b Sette.t
  val reachable_multi :
    'a ->
    'b ->
    ?filter:('b -> bool) ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a Sette.t * 'b Sette.t
  val cfc :
    ?priority:'b SHGraph.priority ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a list list
  val cfc_multi :
    'a ->
    'b ->
    ?priority:'b SHGraph.priority ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a list list
  val scfc :
    ?priority:'b SHGraph.priority ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> (unit, 'a) Ilist.t
  val scfc_multi :
    'a ->
    'b ->
    ?priority:'b SHGraph.priority ->
    ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> (unit, '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 :
    ?style:string ->
    ?titlestyle:string ->
    ?vertexstyle:string ->
    ?hedgestyle:string ->
    ?fvertexstyle:('a -> string) ->
    ?fhedgestyle:('b -> 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
  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
          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 = hedge
          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 HashV :
        sig
          type key = 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 = 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
    end
  module type S =
    sig
      type vertex
      type hedge
      val vertex_dummy : SHGraph.S.vertex
      val hedge_dummy : SHGraph.S.hedge
      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 SetH :
        sig
          type elt = hedge
          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 HashV :
        sig
          type key = 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 = 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 : (SHGraph.S.vertex, SHGraph.S.hedge) SHGraph.compare
      type ('a, 'b, 'c) t
      val create : int -> 'c -> ('a, 'b, 'c) 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 replace_attrvertex :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> 'a -> unit
      val replace_attrhedge :
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.hedge -> 'b -> 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 -> 'g -> 'g) ->
        'g -> 'g
      val fold_hedge :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.hedge ->
         'b ->
         pred:SHGraph.S.vertex array ->
         succ:SHGraph.S.vertex array -> 'g -> 'g) ->
        'g -> 'g
      val map :
        ('a, 'b, 'c) SHGraph.S.t ->
        (SHGraph.S.vertex -> 'a -> 'aa) ->
        (SHGraph.S.hedge -> 'b -> 'bb) ->
        ('c -> 'cc) -> ('aa, 'bb, 'cc) SHGraph.S.t
      val copy :
        (SHGraph.S.vertex -> 'a -> 'aa) ->
        (SHGraph.S.hedge -> 'b -> 'bb) ->
        ('c -> 'cc) ->
        ('a, 'b, 'c) SHGraph.S.t -> ('aa, 'bb, 'cc) SHGraph.S.t
      val transpose :
        (SHGraph.S.vertex -> 'a -> 'aa) ->
        (SHGraph.S.hedge -> 'b -> 'bb) ->
        ('c -> 'cc) ->
        ('a, 'b, 'c) SHGraph.S.t -> ('aa, 'bb, 'cc) 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 :
        ?priority:SHGraph.S.hedge SHGraph.priority ->
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.vertex -> SHGraph.S.vertex list
      val topological_sort_multi :
        ?priority:SHGraph.S.hedge SHGraph.priority ->
        ('a, 'b, 'c) SHGraph.S.t -> SHGraph.S.SetV.t -> SHGraph.S.vertex list
      val reachable :
        ?filter:(SHGraph.S.hedge -> bool) ->
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.vertex -> SHGraph.S.SetV.t * SHGraph.S.SetH.t
      val reachable_multi :
        ?filter:(SHGraph.S.hedge -> bool) ->
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.SetV.t -> SHGraph.S.SetV.t * SHGraph.S.SetH.t
      val cfc :
        ?priority:SHGraph.S.hedge SHGraph.priority ->
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.vertex -> SHGraph.S.vertex list list
      val cfc_multi :
        ?priority:SHGraph.S.hedge SHGraph.priority ->
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.SetV.t -> SHGraph.S.vertex list list
      val scfc :
        ?priority:SHGraph.S.hedge SHGraph.priority ->
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.vertex -> (unit, SHGraph.S.vertex) Ilist.t
      val scfc_multi :
        ?priority:SHGraph.S.hedge SHGraph.priority ->
        ('a, 'b, 'c) SHGraph.S.t ->
        SHGraph.S.SetV.t -> (unit, 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 :
        ?style:string ->
        ?titlestyle:string ->
        ?vertexstyle:string ->
        ?hedgestyle:string ->
        ?fvertexstyle:(SHGraph.S.vertex -> string) ->
        ?fhedgestyle:(SHGraph.S.hedge -> 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
        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
  module Compare :
    sig
      val attrvertex :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a -> 'd
      val attrhedge :
        ('a, 'b) SHGraph.compare ->
        ('c, 'b, 'd, 'e, 'f) SHGraph.graph -> 'b -> 'e
      val is_vertex :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a -> bool
      val is_hedge :
        ('a, 'b) SHGraph.compare ->
        ('c, 'b, 'd, 'e, 'f) SHGraph.graph -> 'b -> bool
      val succhedge :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a -> 'c Sette.t
      val predhedge :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a -> 'c Sette.t
      val succvertex :
        ('a, 'b) SHGraph.compare ->
        ('c, 'b, 'd, 'e, 'f) SHGraph.graph -> 'b -> 'c array
      val predvertex :
        ('a, 'b) SHGraph.compare ->
        ('c, 'b, 'd, 'e, 'f) SHGraph.graph -> 'b -> 'c array
      val succ_vertex :
        ('a, 'b) SHGraph.compare ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'a -> 'a Sette.t
      val pred_vertex :
        ('a, 'b) SHGraph.compare ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'a -> 'a Sette.t
      val add_vertex :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a -> 'd -> unit
      val add_hedge :
        ('a, 'b) SHGraph.compare ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph ->
        'b -> 'd -> pred:'a array -> succ:'a array -> unit
      val replace_attrvertex :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a -> 'd -> unit
      val replace_attrhedge :
        ('a, 'b) SHGraph.compare ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'b -> 'd -> unit
      val remove_hedge :
        ('a, 'b) SHGraph.compare ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'b -> unit
      val remove_vertex :
        ('a, 'b) SHGraph.compare ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'a -> unit
      val topological_sort :
        ('a, 'b) SHGraph.compare ->
        ?priority:'b SHGraph.priority ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a list
      val topological_sort_multi :
        ('a, 'b) SHGraph.compare ->
        'a ->
        'b ->
        ?priority:'b SHGraph.priority ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a Sette.t -> 'a list
      val reachable :
        ('a, 'b) SHGraph.compare ->
        ?filter:('b -> bool) ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.t -> 'a -> 'a Sette.t * 'b Sette.t
      val reachable_multi :
        ('a, 'b) SHGraph.compare ->
        'a ->
        'b ->
        ?filter:('b -> bool) ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.t ->
        'a Sette.t -> 'a Sette.t * 'b Sette.t
      val cfc :
        ('a, 'b) SHGraph.compare ->
        ?priority:'b SHGraph.priority ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'a -> 'a list list
      val cfc_multi :
        ('a, 'b) SHGraph.compare ->
        ?priority:'b SHGraph.priority ->
        'a ->
        'b ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'a Sette.t -> 'a list list
      val scfc :
        ('a, 'b) SHGraph.compare ->
        ?priority:'b SHGraph.priority ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph -> 'a -> (unit, 'a) Ilist.t
      val scfc_multi :
        ('a, 'b) SHGraph.compare ->
        'a ->
        'b ->
        ?priority:'b SHGraph.priority ->
        ('a, 'b, 'c, 'd, 'e) SHGraph.graph ->
        'a Sette.t -> (unit, 'a) Ilist.t
      val print :
        ('a, 'b) SHGraph.compare ->
        (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.graph -> unit
      val min :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a Sette.t
      val max :
        ('a, 'b) SHGraph.compare ->
        ('a, 'c, 'd, 'e, 'f) SHGraph.graph -> 'a Sette.t
    end
end