sig
  exception Not_less_than
  module Int :
    sig
      type t = Integer.t
      val le : t -> t -> bool
      val ge : t -> t -> bool
      val lt : t -> t -> bool
      val gt : t -> t -> bool
      val add : t -> t -> t
      val sub : t -> t -> t
      val mul : t -> t -> t
      val native_div : t -> t -> t
      val rem : t -> t -> t
      val pos_div : t -> t -> t
      val divexact : t -> t -> t
      val c_div : t -> t -> t
      val c_rem : t -> t -> t
      val div_rem : t -> t -> t * t
      val cast : size:t -> signed:bool -> value:t -> t
      val abs : t -> t
      val one : t
      val two : t
      val four : t
      val onethousand : t
      val minus_one : t
      val is_zero : t -> bool
      val is_one : t -> bool
      val pgcd : t -> t -> t
      val ppcm : t -> t -> t
      val min : t -> t -> t
      val max : t -> t -> t
      val length : t -> t -> t
      val of_int : int -> t
      val of_int64 : Int64.t -> t
      val of_int32 : Int32.t -> t
      val to_int64 : t -> int64
      val to_int : t -> int
      val to_float : t -> float
      val neg : t -> t
      val succ : t -> t
      val pred : t -> t
      val round_up_to_r : min:t -> r:t -> modu:t -> t
      val round_down_to_r : max:t -> r:t -> modu:t -> t
      val pos_rem : t -> t -> t
      val shift_left : t -> t -> t
      val shift_right : t -> t -> t
      val logand : t -> t -> t
      val logor : t -> t -> t
      val logxor : t -> t -> t
      val lognot : t -> t
      val two_power : t -> t
      val two_power_of_int : int -> t
      val extract_bits : start:t -> stop:t -> t -> t
      val small_nums : t array
      val zero : t
      val eight : t
      val sixteen : t
      val thirtytwo : t
      val div : t -> t -> t
      val billion_one : t
      val shift_right_logical : t -> t -> t
      val two_power_64 : t
      val max_int64 : t
      val min_int64 : t
      val of_string : string -> t
      val to_string : t -> string
      val add_2_64 : t -> t
      val add_2_32 : t -> t
      val is_even : t -> bool
      val round_down_to_zero : t -> t -> t
      val power_int_positive_int : int -> int -> t
      val to_num : t -> Num.num
      val popcount : t -> int
      val ty : t Type.t
      val name : string
      val descr : t Descr.t
      val packed_descr : Structural_descr.pack
      val reprs : t list
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : t -> int
      val pretty_code : Format.formatter -> t -> unit
      val internal_pretty_code :
        Type.precedence -> Format.formatter -> t -> unit
      val pretty : Format.formatter -> t -> unit
      val varname : t -> string
      val mem_project : (Project_skeleton.t -> bool) -> t -> bool
      val copy : t -> t
      module Set :
        sig
          type elt = t
          type t
          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 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 choose : t -> elt
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val of_list : elt list -> t
          val min_elt : t -> elt
          val max_elt : t -> elt
          val nearest_elt_le : elt -> t -> elt
          val nearest_elt_ge : elt -> t -> elt
          val ty : t Type.t
          val name : string
          val descr : t Descr.t
          val packed_descr : Structural_descr.pack
          val reprs : t list
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val hash : t -> int
          val pretty_code : Format.formatter -> t -> unit
          val internal_pretty_code :
            Type.precedence -> Format.formatter -> t -> unit
          val pretty : Format.formatter -> t -> unit
          val varname : t -> string
          val mem_project : (Project_skeleton.t -> bool) -> t -> bool
          val copy : t -> t
        end
      module Map :
        sig
          type key = t
          type +'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a 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_binding : 'a t -> key * 'a
          val max_binding : 'a t -> key * 'a
          val choose : 'a t -> key * 'a
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          module Key :
            sig
              type t = key
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
          module Make :
            functor (Data : Datatype.S->
              sig
                type t = Data.t t
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
        end
      module Hashtbl :
        sig
          type key = t
          type 'a t
          val create : int -> 'a t
          val clear : 'a t -> unit
          val reset : 'a t -> unit
          val copy : 'a t -> 'a t
          val add : 'a t -> key -> '-> unit
          val remove : 'a t -> key -> unit
          val find : 'a t -> key -> 'a
          val find_all : 'a t -> key -> 'a list
          val replace : 'a t -> key -> '-> unit
          val mem : 'a t -> key -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val length : 'a t -> int
          val stats : 'a t -> Hashtbl.statistics
          val iter_sorted :
            ?cmp:(key -> key -> int) -> (key -> '-> unit) -> 'a t -> unit
          val fold_sorted :
            ?cmp:(key -> key -> int) ->
            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val iter_sorted_by_entry :
            cmp:(key * '-> key * '-> int) ->
            (key -> '-> unit) -> 'a t -> unit
          val fold_sorted_by_entry :
            cmp:(key * '-> key * '-> int) ->
            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val iter_sorted_by_value :
            cmp:('-> '-> int) -> (key -> '-> unit) -> 'a t -> unit
          val fold_sorted_by_value :
            cmp:('-> '-> int) ->
            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val structural_descr : Structural_descr.t -> Structural_descr.t
          val make_type : 'Type.t -> 'a t Type.t
          val memo : 'a t -> key -> (key -> 'a) -> 'a
          module Key :
            sig
              type t = key
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
          module Make :
            functor (Data : Datatype.S->
              sig
                type t = Data.t t
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
        end
      val fold : (t -> '-> 'a) -> inf:t -> sup:t -> step:t -> '-> 'a
    end
  module Rel :
    sig
      type t
      val pretty : Abstract_interp.Rel.t Pretty_utils.formatter
      val equal : Abstract_interp.Rel.t -> Abstract_interp.Rel.t -> bool
      val compare : Abstract_interp.Rel.t -> Abstract_interp.Rel.t -> int
      val hash : Abstract_interp.Rel.t -> int
      val zero : Abstract_interp.Rel.t
      val is_zero : Abstract_interp.Rel.t -> bool
      val sub :
        Abstract_interp.Rel.t ->
        Abstract_interp.Rel.t -> Abstract_interp.Rel.t
      val add_abs :
        Abstract_interp.Int.t ->
        Abstract_interp.Rel.t -> Abstract_interp.Int.t
      val sub_abs :
        Abstract_interp.Int.t ->
        Abstract_interp.Int.t -> Abstract_interp.Rel.t
      val pos_rem :
        Abstract_interp.Rel.t ->
        Abstract_interp.Int.t -> Abstract_interp.Rel.t
      val check :
        rem:Abstract_interp.Rel.t -> modu:Abstract_interp.Int.t -> bool
    end
  module Make_Lattice_Base :
    functor (V : Lattice_type.Lattice_Value->
      sig
        type l = V.t
        type t = private Top | Bottom | Value of l
        exception Error_Top
        exception Error_Bottom
        val ty : t Type.t
        val name : string
        val descr : t Descr.t
        val packed_descr : Structural_descr.pack
        val reprs : t list
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
        val pretty_code : Format.formatter -> t -> unit
        val internal_pretty_code :
          Type.precedence -> Format.formatter -> t -> unit
        val pretty : Format.formatter -> t -> unit
        val varname : t -> string
        val mem_project : (Project_skeleton.t -> bool) -> t -> bool
        val copy : t -> t
        val join : t -> t -> t
        val is_included : t -> t -> bool
        val join_and_is_included : t -> t -> t * bool
        val bottom : t
        val top : t
        type widen_hint
        val widen : widen_hint -> t -> t -> t
        val cardinal_zero_or_one : t -> bool
        val narrow : t -> t -> t
        val link : t -> t -> t
        val meet : t -> t -> t
        val intersects : t -> t -> bool
        val project : t -> l
        val inject : l -> t
        val transform : (l -> l -> l) -> t -> t -> t
      end
  module Make_Lattice_Set :
    functor (V : Lattice_type.Lattice_Value->
      sig
        module O :
          sig
            type elt = V.t
            type t
            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 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 choose : t -> elt
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val of_list : elt list -> t
            val min_elt : t -> elt
            val max_elt : t -> elt
            val nearest_elt_le : elt -> t -> elt
            val nearest_elt_ge : elt -> t -> elt
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
          end
        exception Error_Top
        type t = private Set of O.t | Top
        val ty : t Type.t
        val name : string
        val descr : t Descr.t
        val packed_descr : Structural_descr.pack
        val reprs : t list
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
        val pretty_code : Format.formatter -> t -> unit
        val internal_pretty_code :
          Type.precedence -> Format.formatter -> t -> unit
        val pretty : Format.formatter -> t -> unit
        val varname : t -> string
        val mem_project : (Project_skeleton.t -> bool) -> t -> bool
        val copy : t -> t
        val join : t -> t -> t
        val is_included : t -> t -> bool
        val join_and_is_included : t -> t -> t * bool
        val bottom : t
        val top : t
        type widen_hint = O.t
        val widen : widen_hint -> t -> t -> t
        val cardinal_zero_or_one : t -> bool
        val narrow : t -> t -> t
        val link : t -> t -> t
        val meet : t -> t -> t
        val intersects : t -> t -> bool
        val inject_singleton : O.elt -> t
        val inject : O.t -> t
        val empty : t
        val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
        val apply1 : (O.elt -> O.elt) -> t -> t
        val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
        val iter : (O.elt -> unit) -> t -> unit
        val exists : (O.elt -> bool) -> t -> bool
        val for_all : (O.elt -> bool) -> t -> bool
        val project : t -> O.t
        val mem : O.elt -> t -> bool
      end
  module Make_Hashconsed_Lattice_Set :
    functor
      (V : Hptmap.Id_Datatype) (O : sig
                                      type t
                                      val ty : t Type.t
                                      val name : string
                                      val descr : t Descr.t
                                      val packed_descr :
                                        Structural_descr.pack
                                      val reprs : t list
                                      val hash : t -> int
                                      val pretty_code :
                                        Format.formatter -> t -> unit
                                      val internal_pretty_code :
                                        Type.precedence ->
                                        Format.formatter -> t -> unit
                                      val pretty :
                                        Format.formatter -> t -> unit
                                      val varname : t -> string
                                      val mem_project :
                                        (Project_skeleton.t -> bool) ->
                                        t -> bool
                                      val copy : t -> t
                                      module Set :
                                        sig
                                          type elt = t
                                          type t
                                          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 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 choose : t -> elt
                                          val split :
                                            elt -> t -> t * bool * t
                                          val find : elt -> t -> elt
                                          val of_list : elt list -> t
                                          val min_elt : t -> elt
                                          val max_elt : t -> elt
                                          val nearest_elt_le :
                                            elt -> t -> elt
                                          val nearest_elt_ge :
                                            elt -> t -> elt
                                          val ty : t Type.t
                                          val name : string
                                          val descr : t Descr.t
                                          val packed_descr :
                                            Structural_descr.pack
                                          val reprs : t list
                                          val equal : t -> t -> bool
                                          val compare : t -> t -> int
                                          val hash : t -> int
                                          val pretty_code :
                                            Format.formatter -> t -> unit
                                          val internal_pretty_code :
                                            Type.precedence ->
                                            Format.formatter -> t -> unit
                                          val pretty :
                                            Format.formatter -> t -> unit
                                          val varname : t -> string
                                          val mem_project :
                                            (Project_skeleton.t -> bool) ->
                                            t -> bool
                                          val copy : t -> t
                                        end
                                      module Map :
                                        sig
                                          type key = t
                                          type +'a t
                                          val empty : 'a t
                                          val is_empty : 'a t -> bool
                                          val mem : key -> 'a t -> bool
                                          val add : key -> '-> 'a t -> 'a t
                                          val singleton : key -> '-> 'a t
                                          val remove : key -> 'a t -> 'a t
                                          val merge :
                                            (key ->
                                             'a option ->
                                             'b option -> 'c option) ->
                                            'a t -> 'b t -> 'c t
                                          val compare :
                                            ('-> '-> int) ->
                                            'a t -> 'a t -> int
                                          val equal :
                                            ('-> '-> bool) ->
                                            'a t -> 'a t -> bool
                                          val iter :
                                            (key -> '-> unit) ->
                                            'a t -> unit
                                          val fold :
                                            (key -> '-> '-> 'b) ->
                                            'a t -> '-> 'b
                                          val for_all :
                                            (key -> '-> bool) ->
                                            'a t -> bool
                                          val exists :
                                            (key -> '-> bool) ->
                                            'a 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_binding : 'a t -> key * 'a
                                          val max_binding : 'a t -> key * 'a
                                          val choose : 'a t -> key * 'a
                                          val split :
                                            key ->
                                            'a t -> 'a t * 'a option * 'a t
                                          val find : key -> 'a t -> 'a
                                          val map :
                                            ('-> 'b) -> 'a t -> 'b t
                                          val mapi :
                                            (key -> '-> 'b) -> 'a t -> 'b t
                                          module Key :
                                            sig
                                              type t = key
                                              val ty : t Type.t
                                              val name : string
                                              val descr : t Descr.t
                                              val packed_descr :
                                                Structural_descr.pack
                                              val reprs : t list
                                              val equal : t -> t -> bool
                                              val compare : t -> t -> int
                                              val hash : t -> int
                                              val pretty_code :
                                                Format.formatter -> t -> unit
                                              val internal_pretty_code :
                                                Type.precedence ->
                                                Format.formatter -> t -> unit
                                              val pretty :
                                                Format.formatter -> t -> unit
                                              val varname : t -> string
                                              val mem_project :
                                                (Project_skeleton.t -> bool) ->
                                                t -> bool
                                              val copy : t -> t
                                            end
                                          module Make :
                                            functor (Data : Datatype.S->
                                              sig
                                                type t = Data.t t
                                                val ty : t Type.t
                                                val name : string
                                                val descr : t Descr.t
                                                val packed_descr :
                                                  Structural_descr.pack
                                                val reprs : t list
                                                val equal : t -> t -> bool
                                                val compare : t -> t -> int
                                                val hash : t -> int
                                                val pretty_code :
                                                  Format.formatter ->
                                                  t -> unit
                                                val internal_pretty_code :
                                                  Type.precedence ->
                                                  Format.formatter ->
                                                  t -> unit
                                                val pretty :
                                                  Format.formatter ->
                                                  t -> unit
                                                val varname : t -> string
                                                val mem_project :
                                                  (Project_skeleton.t -> bool) ->
                                                  t -> bool
                                                val copy : t -> t
                                              end
                                        end
                                      module Hashtbl :
                                        sig
                                          type key = t
                                          type 'a t
                                          val create : int -> 'a t
                                          val clear : 'a t -> unit
                                          val reset : 'a t -> unit
                                          val copy : 'a t -> 'a t
                                          val add : 'a t -> key -> '-> unit
                                          val remove : 'a t -> key -> unit
                                          val find : 'a t -> key -> 'a
                                          val find_all :
                                            'a t -> key -> 'a list
                                          val replace :
                                            'a t -> key -> '-> unit
                                          val mem : 'a t -> key -> bool
                                          val iter :
                                            (key -> '-> unit) ->
                                            'a t -> unit
                                          val fold :
                                            (key -> '-> '-> 'b) ->
                                            'a t -> '-> 'b
                                          val length : 'a t -> int
                                          val stats :
                                            'a t -> Hashtbl.statistics
                                          val iter_sorted :
                                            ?cmp:(key -> key -> int) ->
                                            (key -> '-> unit) ->
                                            'a t -> unit
                                          val fold_sorted :
                                            ?cmp:(key -> key -> int) ->
                                            (key -> '-> '-> 'b) ->
                                            'a t -> '-> 'b
                                          val iter_sorted_by_entry :
                                            cmp:(key * '-> key * '-> int) ->
                                            (key -> '-> unit) ->
                                            'a t -> unit
                                          val fold_sorted_by_entry :
                                            cmp:(key * '-> key * '-> int) ->
                                            (key -> '-> '-> 'b) ->
                                            'a t -> '-> 'b
                                          val iter_sorted_by_value :
                                            cmp:('-> '-> int) ->
                                            (key -> '-> unit) ->
                                            'a t -> unit
                                          val fold_sorted_by_value :
                                            cmp:('-> '-> int) ->
                                            (key -> '-> '-> 'b) ->
                                            'a t -> '-> 'b
                                          val structural_descr :
                                            Structural_descr.t ->
                                            Structural_descr.t
                                          val make_type :
                                            'Type.t -> 'a t Type.t
                                          val memo :
                                            'a t -> key -> (key -> 'a) -> 'a
                                          module Key :
                                            sig
                                              type t = key
                                              val ty : t Type.t
                                              val name : string
                                              val descr : t Descr.t
                                              val packed_descr :
                                                Structural_descr.pack
                                              val reprs : t list
                                              val equal : t -> t -> bool
                                              val compare : t -> t -> int
                                              val hash : t -> int
                                              val pretty_code :
                                                Format.formatter -> t -> unit
                                              val internal_pretty_code :
                                                Type.precedence ->
                                                Format.formatter -> t -> unit
                                              val pretty :
                                                Format.formatter -> t -> unit
                                              val varname : t -> string
                                              val mem_project :
                                                (Project_skeleton.t -> bool) ->
                                                t -> bool
                                              val copy : t -> t
                                            end
                                          module Make :
                                            functor (Data : Datatype.S->
                                              sig
                                                type t = Data.t t
                                                val ty : t Type.t
                                                val name : string
                                                val descr : t Descr.t
                                                val packed_descr :
                                                  Structural_descr.pack
                                                val reprs : t list
                                                val equal : t -> t -> bool
                                                val compare : t -> t -> int
                                                val hash : t -> int
                                                val pretty_code :
                                                  Format.formatter ->
                                                  t -> unit
                                                val internal_pretty_code :
                                                  Type.precedence ->
                                                  Format.formatter ->
                                                  t -> unit
                                                val pretty :
                                                  Format.formatter ->
                                                  t -> unit
                                                val varname : t -> string
                                                val mem_project :
                                                  (Project_skeleton.t -> bool) ->
                                                  t -> bool
                                                val copy : t -> t
                                              end
                                        end
                                      type elt = V.t
                                      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 choose : t -> elt
                                      val split : elt -> t -> t * bool * t
                                      val find : elt -> t -> elt
                                      val of_list : elt list -> t
                                      val contains_single_elt :
                                        t -> elt option
                                      val intersects : t -> t -> bool
                                      type 'a shape
                                      val shape : t -> unit shape
                                      val from_shape : 'a shape -> t
                                      val fold2_join_heterogeneous :
                                        cache:Hptmap.cache_type ->
                                        empty_left:('a shape -> 'b) ->
                                        empty_right:(t -> 'b) ->
                                        both:(elt -> '-> 'b) ->
                                        join:('-> '-> 'b) ->
                                        empty:'-> t -> 'a shape -> 'b
                                      val clear_caches : unit -> unit
                                    end->
      sig
        module O :
          sig
            type t = O.t
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
            module Set :
              sig
                type elt = t
                type t = O.Set.t
                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 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 choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
                val min_elt : t -> elt
                val max_elt : t -> elt
                val nearest_elt_le : elt -> t -> elt
                val nearest_elt_ge : elt -> t -> elt
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
            module Map :
              sig
                type key = t
                type 'a t = 'O.Map.t
                val empty : 'a t
                val is_empty : 'a t -> bool
                val mem : key -> 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val singleton : key -> '-> 'a t
                val remove : key -> 'a t -> 'a t
                val merge :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val for_all : (key -> '-> bool) -> 'a t -> bool
                val exists : (key -> '-> bool) -> 'a 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_binding : 'a t -> key * 'a
                val max_binding : 'a t -> key * 'a
                val choose : 'a t -> key * 'a
                val split : key -> 'a t -> 'a t * 'a option * 'a t
                val find : key -> 'a t -> 'a
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                module Key :
                  sig
                    type t = key
                    val ty : t Type.t
                    val name : string
                    val descr : t Descr.t
                    val packed_descr : Structural_descr.pack
                    val reprs : t list
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val hash : t -> int
                    val pretty_code : Format.formatter -> t -> unit
                    val internal_pretty_code :
                      Type.precedence -> Format.formatter -> t -> unit
                    val pretty : Format.formatter -> t -> unit
                    val varname : t -> string
                    val mem_project :
                      (Project_skeleton.t -> bool) -> t -> bool
                    val copy : t -> t
                  end
                module Make :
                  functor (Data : Datatype.S->
                    sig
                      type t = Data.t t
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
              end
            module Hashtbl :
              sig
                type key = t
                type 'a t = 'O.Hashtbl.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val reset : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
                val stats : 'a t -> Hashtbl.statistics
                val iter_sorted :
                  ?cmp:(key -> key -> int) ->
                  (key -> '-> unit) -> 'a t -> unit
                val fold_sorted :
                  ?cmp:(key -> key -> int) ->
                  (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val iter_sorted_by_entry :
                  cmp:(key * '-> key * '-> int) ->
                  (key -> '-> unit) -> 'a t -> unit
                val fold_sorted_by_entry :
                  cmp:(key * '-> key * '-> int) ->
                  (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val iter_sorted_by_value :
                  cmp:('-> '-> int) ->
                  (key -> '-> unit) -> 'a t -> unit
                val fold_sorted_by_value :
                  cmp:('-> '-> int) ->
                  (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val structural_descr :
                  Structural_descr.t -> Structural_descr.t
                val make_type : 'Type.t -> 'a t Type.t
                val memo : 'a t -> key -> (key -> 'a) -> 'a
                module Key :
                  sig
                    type t = key
                    val ty : t Type.t
                    val name : string
                    val descr : t Descr.t
                    val packed_descr : Structural_descr.pack
                    val reprs : t list
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val hash : t -> int
                    val pretty_code : Format.formatter -> t -> unit
                    val internal_pretty_code :
                      Type.precedence -> Format.formatter -> t -> unit
                    val pretty : Format.formatter -> t -> unit
                    val varname : t -> string
                    val mem_project :
                      (Project_skeleton.t -> bool) -> t -> bool
                    val copy : t -> t
                  end
                module Make :
                  functor (Data : Datatype.S->
                    sig
                      type t = Data.t t
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
              end
            type elt = V.t
            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 choose : t -> elt
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val of_list : elt list -> t
            val contains_single_elt : t -> elt option
            val intersects : t -> t -> bool
            type 'a shape = 'O.shape
            val shape : t -> unit shape
            val from_shape : 'a shape -> t
            val fold2_join_heterogeneous :
              cache:Hptmap.cache_type ->
              empty_left:('a shape -> 'b) ->
              empty_right:(t -> 'b) ->
              both:(elt -> '-> 'b) ->
              join:('-> '-> 'b) -> empty:'-> t -> 'a shape -> 'b
            val clear_caches : unit -> unit
          end
        exception Error_Top
        type t = private Set of O.t | Top
        val ty : t Type.t
        val name : string
        val descr : t Descr.t
        val packed_descr : Structural_descr.pack
        val reprs : t list
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
        val pretty_code : Format.formatter -> t -> unit
        val internal_pretty_code :
          Type.precedence -> Format.formatter -> t -> unit
        val pretty : Format.formatter -> t -> unit
        val varname : t -> string
        val mem_project : (Project_skeleton.t -> bool) -> t -> bool
        val copy : t -> t
        val join : t -> t -> t
        val is_included : t -> t -> bool
        val join_and_is_included : t -> t -> t * bool
        val bottom : t
        val top : t
        type widen_hint = O.t
        val widen : widen_hint -> t -> t -> t
        val cardinal_zero_or_one : t -> bool
        val narrow : t -> t -> t
        val link : t -> t -> t
        val meet : t -> t -> t
        val intersects : t -> t -> bool
        val inject_singleton : O.elt -> t
        val inject : O.t -> t
        val empty : t
        val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
        val apply1 : (O.elt -> O.elt) -> t -> t
        val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
        val iter : (O.elt -> unit) -> t -> unit
        val exists : (O.elt -> bool) -> t -> bool
        val for_all : (O.elt -> bool) -> t -> bool
        val project : t -> O.t
        val mem : O.elt -> t -> bool
      end
  module type Collapse = sig val collapse : bool end
  module Make_Lattice_Product :
    functor
      (L1 : Lattice_type.AI_Lattice_with_cardinal_one) (L2 : Lattice_type.AI_Lattice_with_cardinal_one) (C : Collapse->
      sig
        type t1 = L1.t
        type t2 = L2.t
        type t = private Product of t1 * t2 | Bottom
        val ty : t Type.t
        val name : string
        val descr : t Descr.t
        val packed_descr : Structural_descr.pack
        val reprs : t list
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
        val pretty_code : Format.formatter -> t -> unit
        val internal_pretty_code :
          Type.precedence -> Format.formatter -> t -> unit
        val pretty : Format.formatter -> t -> unit
        val varname : t -> string
        val mem_project : (Project_skeleton.t -> bool) -> t -> bool
        val copy : t -> t
        val join : t -> t -> t
        val is_included : t -> t -> bool
        val join_and_is_included : t -> t -> t * bool
        val bottom : t
        val top : t
        type widen_hint
        val widen : widen_hint -> t -> t -> t
        val cardinal_zero_or_one : t -> bool
        val narrow : t -> t -> t
        val link : t -> t -> t
        val meet : t -> t -> t
        val intersects : t -> t -> bool
        val inject : t1 -> t2 -> t
        val fst : t -> t1
        val snd : t -> t2
      end
  module Make_Lattice_UProduct :
    functor
      (L1 : Lattice_type.AI_Lattice_with_cardinal_one) (L2 : Lattice_type.AI_Lattice_with_cardinal_one->
      sig
        type t1 = L1.t
        type t2 = L2.t
        type tt = t1 * t2
        type t = tt
        val ty : t Type.t
        val name : string
        val descr : t Descr.t
        val packed_descr : Structural_descr.pack
        val reprs : t list
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
        val pretty_code : Format.formatter -> t -> unit
        val internal_pretty_code :
          Type.precedence -> Format.formatter -> t -> unit
        val pretty : Format.formatter -> t -> unit
        val varname : t -> string
        val mem_project : (Project_skeleton.t -> bool) -> t -> bool
        val copy : t -> t
        val join : t -> t -> t
        val is_included : t -> t -> bool
        val join_and_is_included : t -> t -> t * bool
        val bottom : t
        val top : t
        type widen_hint
        val widen : widen_hint -> t -> t -> t
        val cardinal_zero_or_one : t -> bool
        val narrow : t -> t -> t
        val link : t -> t -> t
        val meet : t -> t -> t
        val intersects : t -> t -> bool
      end
  module Make_Lattice_Sum :
    functor
      (L1 : Lattice_type.AI_Lattice_with_cardinal_one) (L2 : Lattice_type.AI_Lattice_with_cardinal_one->
      sig
        type t1 = L1.t
        type t2 = L2.t
        type sum = private Top | Bottom | T1 of t1 | T2 of t2
        type t = sum
        val ty : t Type.t
        val name : string
        val descr : t Descr.t
        val packed_descr : Structural_descr.pack
        val reprs : t list
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
        val pretty_code : Format.formatter -> t -> unit
        val internal_pretty_code :
          Type.precedence -> Format.formatter -> t -> unit
        val pretty : Format.formatter -> t -> unit
        val varname : t -> string
        val mem_project : (Project_skeleton.t -> bool) -> t -> bool
        val copy : t -> t
        val join : t -> t -> t
        val is_included : t -> t -> bool
        val join_and_is_included : t -> t -> t * bool
        val bottom : t
        val top : t
        type widen_hint
        val widen : widen_hint -> t -> t -> t
        val cardinal_zero_or_one : t -> bool
        val narrow : t -> t -> t
        val link : t -> t -> t
        val meet : t -> t -> t
        val intersects : t -> t -> bool
        val inject_t1 : t1 -> t
        val inject_t2 : t2 -> t
      end
end