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