sig
  type key = int
  type 'a t
  val empty : 'a t
  val lookup : key -> 'a t -> 'a
  val find : key -> 'a t -> 'a
  val add : key -> 'a -> 'a t -> 'a t
  exception Unchanged
  val strict_add : key -> 'a -> 'a t -> 'a t
  type 'a decision = 'a -> 'a -> 'a
  val fine_add : 'a decision -> key -> 'a -> 'a t -> 'a t
  val mem : key -> 'a t -> bool
  val singleton : key -> 'a -> 'a t
  val is_empty : 'a t -> bool
  val is_singleton : 'a t -> (key * 'a) option
  val cardinal : 'a t -> int
  val choose : 'a t -> key * 'a
  val lookup_and_remove : key -> 'a t -> 'a * 'a t
  val find_and_remove : key -> 'a t -> 'a * 'a t
  val remove : key -> 'a t -> 'a t
  val union : 'a t -> 'a t -> 'a t
  val fine_union : 'a decision -> 'a t -> 'a t -> 'a t
  val iter : (key -> 'a -> unit) -> 'a t -> unit
  val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
  val fold_rev : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
  val iter2 : (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
  val map : ('a -> 'b) -> 'a t -> 'b t
  val endo_map : ('a -> 'a) -> 'a t -> 'a t
  val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
  module Domain :
    sig
      type element = key
      type t
      val empty : t
      val is_empty : t -> bool
      val singleton : element -> t
      val cardinal : t -> int
      val choose : t -> element
      val mem : element -> t -> bool
      val add : element -> t -> t
      val remove : element -> t -> t
      val union : t -> t -> t
      val diff : t -> t -> t
      val inter : t -> t -> t
      val disjoint : t -> t -> bool
      val iter : (element -> unit) -> t -> unit
      val fold : (element -> 'b -> 'b) -> t -> 'b -> 'b
      val elements : t -> element list
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
    end
  val domain : 'a t -> Domain.t
  val lift : (key -> 'a) -> Domain.t -> 'a t
  val corestrict : 'a t -> Domain.t -> 'a t
end