sig
  module type OrderedType =
    sig
      type t
      val compare : Pqueue.OrderedType.t -> Pqueue.OrderedType.t -> int
    end
  module type Min =
    sig
      type t
      type elt
      val create : unit -> Pqueue.Min.t
      val length : Pqueue.Min.t -> int
      val is_empty : Pqueue.Min.t -> bool
      val add : Pqueue.Min.t -> Pqueue.Min.elt -> unit
      val add_iter :
        Pqueue.Min.t ->
        ((Pqueue.Min.elt -> unit) -> 'x -> unit) -> 'x -> unit
      val min_elt : Pqueue.Min.t -> Pqueue.Min.elt option
      val get_min_elt : Pqueue.Min.t -> Pqueue.Min.elt
      val pop_min : Pqueue.Min.t -> Pqueue.Min.elt option
      val remove_min : Pqueue.Min.t -> unit
      val clear : Pqueue.Min.t -> unit
      val copy : Pqueue.Min.t -> Pqueue.Min.t
      val of_array : Pqueue.Min.elt array -> Pqueue.Min.t
      val of_list : Pqueue.Min.elt list -> Pqueue.Min.t
      val of_iter :
        ((Pqueue.Min.elt -> unit) -> 'x -> unit) -> 'x -> Pqueue.Min.t
      val iter_unordered : (Pqueue.Min.elt -> unit) -> Pqueue.Min.t -> unit
      val fold_unordered :
        ('acc -> Pqueue.Min.elt -> 'acc) -> 'acc -> Pqueue.Min.t -> 'acc
    end
  module MakeMin :
    (E : OrderedType) ->
      sig
        type t
        val create : unit -> t
        val length : t -> int
        val is_empty : t -> bool
        val add : t -> E.t -> unit
        val add_iter : t -> ((E.t -> unit) -> 'x -> unit) -> 'x -> unit
        val min_elt : t -> E.t option
        val get_min_elt : t -> E.t
        val pop_min : t -> E.t option
        val remove_min : t -> unit
        val clear : t -> unit
        val copy : t -> t
        val of_array : E.t array -> t
        val of_list : E.t list -> t
        val of_iter : ((E.t -> unit) -> 'x -> unit) -> 'x -> t
        val iter_unordered : (E.t -> unit) -> t -> unit
        val fold_unordered : ('acc -> E.t -> 'acc) -> 'acc -> t -> 'acc
      end
  module type Max =
    sig
      type t
      type elt
      val create : unit -> Pqueue.Max.t
      val length : Pqueue.Max.t -> int
      val is_empty : Pqueue.Max.t -> bool
      val add : Pqueue.Max.t -> Pqueue.Max.elt -> unit
      val add_iter :
        Pqueue.Max.t ->
        ((Pqueue.Max.elt -> unit) -> 'x -> unit) -> 'x -> unit
      val max_elt : Pqueue.Max.t -> Pqueue.Max.elt option
      val get_max_elt : Pqueue.Max.t -> Pqueue.Max.elt
      val pop_max : Pqueue.Max.t -> Pqueue.Max.elt option
      val remove_max : Pqueue.Max.t -> unit
      val clear : Pqueue.Max.t -> unit
      val copy : Pqueue.Max.t -> Pqueue.Max.t
      val of_array : Pqueue.Max.elt array -> Pqueue.Max.t
      val of_list : Pqueue.Max.elt list -> Pqueue.Max.t
      val of_iter :
        ((Pqueue.Max.elt -> unit) -> 'x -> unit) -> 'x -> Pqueue.Max.t
      val iter_unordered : (Pqueue.Max.elt -> unit) -> Pqueue.Max.t -> unit
      val fold_unordered :
        ('acc -> Pqueue.Max.elt -> 'acc) -> 'acc -> Pqueue.Max.t -> 'acc
    end
  module MakeMax :
    (E : OrderedType) ->
      sig
        type t
        val create : unit -> t
        val length : t -> int
        val is_empty : t -> bool
        val add : t -> E.t -> unit
        val add_iter : t -> ((E.t -> unit) -> 'x -> unit) -> 'x -> unit
        val max_elt : t -> E.t option
        val get_max_elt : t -> E.t
        val pop_max : t -> E.t option
        val remove_max : t -> unit
        val clear : t -> unit
        val copy : t -> t
        val of_array : E.t array -> t
        val of_list : E.t list -> t
        val of_iter : ((E.t -> unit) -> 'x -> unit) -> 'x -> t
        val iter_unordered : (E.t -> unit) -> t -> unit
        val fold_unordered : ('acc -> E.t -> 'acc) -> 'acc -> t -> 'acc
      end
  module type OrderedPolyType =
    sig
      type 'a t
      val compare :
        'a Pqueue.OrderedPolyType.t -> 'b Pqueue.OrderedPolyType.t -> int
    end
  module type MinPoly =
    sig
      type 'a t
      type 'a elt
      val create : unit -> 'a Pqueue.MinPoly.t
      val length : 'a Pqueue.MinPoly.t -> int
      val is_empty : 'a Pqueue.MinPoly.t -> bool
      val add : 'a Pqueue.MinPoly.t -> 'a Pqueue.MinPoly.elt -> unit
      val add_iter :
        'a Pqueue.MinPoly.t ->
        (('a Pqueue.MinPoly.elt -> unit) -> 'x -> unit) -> 'x -> unit
      val min_elt : 'a Pqueue.MinPoly.t -> 'a Pqueue.MinPoly.elt option
      val get_min_elt : 'a Pqueue.MinPoly.t -> 'a Pqueue.MinPoly.elt
      val pop_min : 'a Pqueue.MinPoly.t -> 'a Pqueue.MinPoly.elt option
      val remove_min : 'a Pqueue.MinPoly.t -> unit
      val clear : 'a Pqueue.MinPoly.t -> unit
      val copy : 'a Pqueue.MinPoly.t -> 'a Pqueue.MinPoly.t
      val of_array : 'a Pqueue.MinPoly.elt array -> 'a Pqueue.MinPoly.t
      val of_list : 'a Pqueue.MinPoly.elt list -> 'a Pqueue.MinPoly.t
      val of_iter :
        (('a Pqueue.MinPoly.elt -> unit) -> 'x -> unit) ->
        'x -> 'a Pqueue.MinPoly.t
      val iter_unordered :
        ('a Pqueue.MinPoly.elt -> unit) -> 'a Pqueue.MinPoly.t -> unit
      val fold_unordered :
        ('acc -> 'a Pqueue.MinPoly.elt -> 'acc) ->
        'acc -> 'a Pqueue.MinPoly.t -> 'acc
    end
  module MakeMinPoly :
    (E : OrderedPolyType) ->
      sig
        type 'a t
        val create : unit -> 'a t
        val length : 'a t -> int
        val is_empty : 'a t -> bool
        val add : 'a t -> 'a E.t -> unit
        val add_iter : 'a t -> (('a E.t -> unit) -> 'x -> unit) -> 'x -> unit
        val min_elt : 'a t -> 'a E.t option
        val get_min_elt : 'a t -> 'a E.t
        val pop_min : 'a t -> 'a E.t option
        val remove_min : 'a t -> unit
        val clear : 'a t -> unit
        val copy : 'a t -> 'a t
        val of_array : 'a E.t array -> 'a t
        val of_list : 'a E.t list -> 'a t
        val of_iter : (('a E.t -> unit) -> 'x -> unit) -> 'x -> 'a t
        val iter_unordered : ('a E.t -> unit) -> 'a t -> unit
        val fold_unordered : ('acc -> 'a E.t -> 'acc) -> 'acc -> 'a t -> 'acc
      end
  module type MaxPoly =
    sig
      type 'a t
      type 'a elt
      val create : unit -> 'a Pqueue.MaxPoly.t
      val length : 'a Pqueue.MaxPoly.t -> int
      val is_empty : 'a Pqueue.MaxPoly.t -> bool
      val add : 'a Pqueue.MaxPoly.t -> 'a Pqueue.MaxPoly.elt -> unit
      val add_iter :
        'a Pqueue.MaxPoly.t ->
        (('a Pqueue.MaxPoly.elt -> unit) -> 'x -> unit) -> 'x -> unit
      val max_elt : 'a Pqueue.MaxPoly.t -> 'a Pqueue.MaxPoly.elt option
      val get_max_elt : 'a Pqueue.MaxPoly.t -> 'a Pqueue.MaxPoly.elt
      val pop_max : 'a Pqueue.MaxPoly.t -> 'a Pqueue.MaxPoly.elt option
      val remove_max : 'a Pqueue.MaxPoly.t -> unit
      val clear : 'a Pqueue.MaxPoly.t -> unit
      val copy : 'a Pqueue.MaxPoly.t -> 'a Pqueue.MaxPoly.t
      val of_array : 'a Pqueue.MaxPoly.elt array -> 'a Pqueue.MaxPoly.t
      val of_list : 'a Pqueue.MaxPoly.elt list -> 'a Pqueue.MaxPoly.t
      val of_iter :
        (('a Pqueue.MaxPoly.elt -> unit) -> 'x -> unit) ->
        'x -> 'a Pqueue.MaxPoly.t
      val iter_unordered :
        ('a Pqueue.MaxPoly.elt -> unit) -> 'a Pqueue.MaxPoly.t -> unit
      val fold_unordered :
        ('acc -> 'a Pqueue.MaxPoly.elt -> 'acc) ->
        'acc -> 'a Pqueue.MaxPoly.t -> 'acc
    end
  module MakeMaxPoly :
    (E : OrderedPolyType) ->
      sig
        type 'a t
        val create : unit -> 'a t
        val length : 'a t -> int
        val is_empty : 'a t -> bool
        val add : 'a t -> 'a E.t -> unit
        val add_iter : 'a t -> (('a E.t -> unit) -> 'x -> unit) -> 'x -> unit
        val max_elt : 'a t -> 'a E.t option
        val get_max_elt : 'a t -> 'a E.t
        val pop_max : 'a t -> 'a E.t option
        val remove_max : 'a t -> unit
        val clear : 'a t -> unit
        val copy : 'a t -> 'a t
        val of_array : 'a E.t array -> 'a t
        val of_list : 'a E.t list -> 'a t
        val of_iter : (('a E.t -> unit) -> 'x -> unit) -> 'x -> 'a t
        val iter_unordered : ('a E.t -> unit) -> 'a t -> unit
        val fold_unordered : ('acc -> 'a E.t -> 'acc) -> 'acc -> 'a t -> 'acc
      end
end