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) DMappe.t -> ('a, 'b) DMappe.t
  val y_of_x : '-> ('a, 'b) DMappe.t -> 'b
  val x_of_y : '-> ('b, 'a) DMappe.t -> 'b
  val remove : '-> ('a, 'b) DMappe.t -> ('a, 'b) DMappe.t
  val memx : '-> ('a, 'b) DMappe.t -> bool
  val memy : '-> ('b, 'a) 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 -> 'Sette.t -> ('a, 'b) DMappe.t
  val intersety : ('a, 'b) DMappe.t -> 'Sette.t -> ('a, 'b) DMappe.t
  val diffsetx : ('a, 'b) DMappe.t -> 'Sette.t -> ('a, 'b) DMappe.t
  val diffsety : ('a, 'b) DMappe.t -> 'Sette.t -> ('a, 'b) DMappe.t
  val iter : ('-> '-> unit) -> ('a, 'b) DMappe.t -> unit
  val fold : ('-> '-> '-> 'c) -> ('a, 'b) DMappe.t -> '-> 'c
  val setx : ('a, 'b) DMappe.t -> 'Sette.t
  val sety : ('a, 'b) DMappe.t -> '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 -> '-> unit) ->
    (Format.formatter -> '-> 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 -> '-> 'a) -> DMappe.S.t -> '-> 'a
      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 = '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) -> t -> '-> '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 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 t -> 'a t -> 'a t
            val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> '-> '-> '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 -> '-> unit) -> 'a t -> unit
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('-> '-> int) -> 'a t -> 'b t -> int
            val comparei : (key -> '-> '-> int) -> 'a t -> 'b t -> int
            val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
            val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
            val filter : (key -> '-> bool) -> 'a t -> 'a t
            val partition : (key -> '-> 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 -> '-> unit) ->
              Format.formatter -> 'a t -> unit
          end
        module MappeY :
          sig
            type key = P.MappeY.key
            type 'a t = '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) -> t -> '-> '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 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 t -> 'a t -> 'a t
            val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> '-> '-> '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 -> '-> unit) -> 'a t -> unit
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('-> '-> int) -> 'a t -> 'b t -> int
            val comparei : (key -> '-> '-> int) -> 'a t -> 'b t -> int
            val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
            val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
            val filter : (key -> '-> bool) -> 'a t -> 'a t
            val partition : (key -> '-> 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 -> '-> unit) ->
&.bsp;nbrp;            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 -> '-> 'a) -> t -> '-> 'a
        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