sig
  type ('a, 'b) t
  val mapx : ('a, 'b) DMappe.t -> ('a, 'b) Mappe.t
  val mapy : ('a, 'b) DMappe.t -> ('b, 'a) Mappe.t
  val empty : ('a, 'b) DMappe.t
  val add : 'a -> 'b -> ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t
  val y_of_x : 'a -> ('a, 'b) DMappe.t -> 'b
  val x_of_y : 'b -> ('a, 'b) DMappe.t -> 'a
  val remove : 'a -> ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t
  val memx : 'a -> ('a, 'b) DMappe.t -> bool
  val memy : 'b -> ('a, 'b) DMappe.t -> bool
  val merge : ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t
  val common : ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t
  val intersetx : ('a, 'b) DMappe.t -> 'a Sette.t -> ('a, 'b) DMappe.t
  val intersety : ('a, 'b) DMappe.t -> 'b Sette.t -> ('a, 'b) DMappe.t
  val diffsetx : ('a, 'b) DMappe.t -> 'a Sette.t -> ('a, 'b) DMappe.t
  val diffsety : ('a, 'b) DMappe.t -> 'b Sette.t -> ('a, 'b) DMappe.t
  val iter : ('a -> 'b -> unit) -> ('a, 'b) DMappe.t -> unit
  val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) DMappe.t -> 'c -> 'c
  val setx : ('a, 'b) DMappe.t -> 'a Sette.t
  val sety : ('a, 'b) DMappe.t -> 'b Sette.t
  val equalx : ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t -> bool
  val equaly : ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t -> bool
  val subsetx : ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t -> bool
  val subsety : ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t -> bool
  val cardinal : ('a, 'b) DMappe.t -> int
  val print :
    ?first:(unit, Format.formatter, unit) Pervasives.format ->
    ?sep:(unit, Format.formatter, unit) Pervasives.format ->
    ?last:(unit, Format.formatter, unit) Pervasives.format ->
    ?firstbind:(unit, Format.formatter, unit) Pervasives.format ->
    ?sepbind:(unit, Format.formatter, unit) Pervasives.format ->
    ?lastbind:(unit, Format.formatter, unit) Pervasives.format ->
    (Format.formatter -> 'a -> unit) ->
    (Format.formatter -> 'b -> unit) ->
    Format.formatter -> ('a, 'b) DMappe.t -> unit
  module type Param = sig module MappeX : Mappe.S module MappeY : Mappe.S end
  module type S =
    sig
      module MappeX : Mappe.S
      module MappeY : Mappe.S
      type x = MappeX.key
      type y = MappeY.key
      type t
      val mapx : DMappe.S.t -> DMappe.S.y MappeX.t
      val mapy : DMappe.S.t -> DMappe.S.x MappeY.t
      val is_empty : DMappe.S.t -> bool
      val empty : DMappe.S.t
      val add : DMappe.S.x -> DMappe.S.y -> DMappe.S.t -> DMappe.S.t
      val y_of_x : DMappe.S.x -> DMappe.S.t -> DMappe.S.y
      val x_of_y : DMappe.S.y -> DMappe.S.t -> DMappe.S.x
      val remove : DMappe.S.x -> DMappe.S.t -> DMappe.S.t
      val memx : DMappe.S.x -> DMappe.S.t -> bool
      val memy : DMappe.S.y -> DMappe.S.t -> bool
      val merge : DMappe.S.t -> DMappe.S.t -> DMappe.S.t
      val common : DMappe.S.t -> DMappe.S.t -> DMappe.S.t
      val intersetx : DMappe.S.t -> MappeX.Setkey.t -> DMappe.S.t
      val intersety : DMappe.S.t -> MappeY.Setkey.t -> DMappe.S.t
      val diffsetx : DMappe.S.t -> MappeX.Setkey.t -> DMappe.S.t
      val diffsety : DMappe.S.t -> MappeY.Setkey.t -> DMappe.S.t
      val iter : (DMappe.S.x -> DMappe.S.y -> unit) -> DMappe.S.t -> unit
      val fold :
        (DMappe.S.x -> DMappe.S.y -> 'c -> 'c) -> DMappe.S.t -> 'c -> 'c
      val setx : DMappe.S.t -> MappeX.Setkey.t
      val sety : DMappe.S.t -> MappeY.Setkey.t
      val equalx : DMappe.S.t -> DMappe.S.t -> bool
      val equaly : DMappe.S.t -> DMappe.S.t -> bool
      val subsetx : DMappe.S.t -> DMappe.S.t -> bool
      val subsety : DMappe.S.t -> DMappe.S.t -> bool
      val cardinal : DMappe.S.t -> int
      val print :
        ?first:(unit, Format.formatter, unit) Pervasives.format ->
        ?sep:(unit, Format.formatter, unit) Pervasives.format ->
        ?last:(unit, Format.formatter, unit) Pervasives.format ->
        ?firstbind:(unit, Format.formatter, unit) Pervasives.format ->
        ?sepbind:(unit, Format.formatter, unit) Pervasives.format ->
        ?lastbind:(unit, Format.formatter, unit) Pervasives.format ->
        (Format.formatter -> DMappe.S.x -> unit) ->
        (Format.formatter -> DMappe.S.y -> unit) ->
        Format.formatter -> DMappe.S.t -> unit
    end
  module Make :
    functor (P : Param) ->
      sig
        module MappeX :
          sig
            type key = P.MappeX.key
            type 'a t = 'a P.MappeX.t
            module Setkey :
              sig
                type elt = key
                type t = P.MappeX.Setkey.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
            val repr : 'a t -> (key, 'a) Mappe.map
            val obj : (key, 'a) Mappe.map -> 'a t
            val is_empty : 'a t -> bool
            val empty : 'a t
            val add : key -> 'a -> 'a t -> 'a t
            val find : key -> 'a t -> 'a
            val remove : key -> 'a t -> 'a t
            val mem : key -> 'a t -> bool
            val addmap : 'a t -> 'a t -> 'a t
            val merge : ('a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
            val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
            val combine :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val interset : 'a t -> Setkey.t -> 'a t
            val diffset : 'a t -> Setkey.t -> 'a t
            val iter : (key -> 'a -> unit) -> 'a t -> unit
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
            val comparei : (key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
            val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val filter : (key -> 'a -> bool) -> 'a t -> 'a t
            val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
            val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_key : 'a t -> key
            val max_key : 'a t -> key
            val choose : 'a t -> key * 'a
            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 MappeY :
          sig
            type key = P.MappeY.key
            type 'a t = 'a P.MappeY.t
            module Setkey :
              sig
                type elt = key
                type t = P.MappeY.Setkey.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
            val repr : 'a t -> (key, 'a) Mappe.map
            val obj : (key, 'a) Mappe.map -> 'a t
            val is_empty : 'a t -> bool
            val empty : 'a t
            val add : key -> 'a -> 'a t -> 'a t
            val find : key -> 'a t -> 'a
            val remove : key -> 'a t -> 'a t
            val mem : key -> 'a t -> bool
            val addmap : 'a t -> 'a t -> 'a t
            val merge : ('a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
            val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
            val combine :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val interset : 'a t -> Setkey.t -> 'a t
            val diffset : 'a t -> Setkey.t -> 'a t
            val iter : (key -> 'a -> unit) -> 'a t -> unit
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
            val comparei : (key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
            val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
            val filter : (key -> 'a -> bool) -> 'a t -> 'a t
            val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
            val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_key : 'a t -> key
            val max_key : 'a t -> key
            val choose : 'a t -> key * 'a
            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
        type x = MappeX.key
        type y = MappeY.key
        type t
        val mapx : t -> y MappeX.t
        val mapy : t -> x MappeY.t
        val is_empty : t -> bool
        val empty : t
        val add : x -> y -> t -> t
        val y_of_x : x -> t -> y
        val x_of_y : y -> t -> x
        val remove : x -> t -> t
        val memx : x -> t -> bool
        val memy : y -> t -> bool
        val merge : t -> t -> t
        val common : t -> t -> t
        val intersetx : t -> MappeX.Setkey.t -> t
        val intersety : t -> MappeY.Setkey.t -> t
        val diffsetx : t -> MappeX.Setkey.t -> t
        val diffsety : t -> MappeY.Setkey.t -> t
        val iter : (x -> y -> unit) -> t -> unit
        val fold : (x -> y -> 'c -> 'c) -> t -> 'c -> 'c
        val setx : t -> MappeX.Setkey.t
        val sety : t -> MappeY.Setkey.t
        val equalx : t -> t -> bool
        val equaly : t -> t -> bool
        val subsetx : t -> t -> bool
        val subsety : t -> t -> bool
        val cardinal : 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 -> x -> unit) ->
          (Format.formatter -> y -> unit) -> Format.formatter -> t -> unit
      end
end