sig
  exception Error_Top
  exception Error_Bottom
  exception Not_less_than
  exception Can_not_subdiv
  module Comp :
    sig
      type t = Lt | Gt | Le | Ge | Eq | Ne
      type result = True | False | Unknown
      val pretty_comp : Abstract_interp.Comp.t Pretty_utils.formatter
      val inv : Abstract_interp.Comp.t -> Abstract_interp.Comp.t
      val sym : Abstract_interp.Comp.t -> Abstract_interp.Comp.t
      val inv_result :
        Abstract_interp.Comp.result -> Abstract_interp.Comp.result
    end
  module Int :
    sig
      type t = Integer.t
      exception Too_big
      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 of_float : float -> t
      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 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 add :
        Abstract_interp.Rel.t ->
        Abstract_interp.Rel.t -> Abstract_interp.Rel.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 Bool :
    sig
      type t = Top | True | False | 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 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 diff : t -> t -> t
      val diff_if_one : t -> t -> t
      val fold_enum : (t -> '-> 'a) -> t -> '-> 'a
      val cardinal_less_than : t -> int -> int
    end
  module Make_Lattice_Base :
    functor (V : Lattice_type.Lattice_Value->
      sig
        type l = V.t
        type t = private Top | Bottom | Value of l
        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 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 : Datatype.S) (Set : 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 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->
      sig
        module O :
          sig
            type elt = V.t
            type t = 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 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
        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 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 filter : (O.elt -> bool) -> t -> t
        val project : t -> O.t
        val mem : O.elt -> t -> bool
      end
  module Make_Hashconsed_Lattice_Set :
    functor
      (V : Hptmap.Id_Datatype) (Set : 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 action =
                                            Neutral
                                          | Absorbing
                                          | Traversing of (elt -> bool)
                                        val merge :
                                          cache:Hptmap_sig.cache_type ->
                                          symmetric:bool ->
                                          idempotent:bool ->
                                          decide_both:(elt -> bool) ->
                                          decide_left:action ->
                                          decide_right:action -> t -> t -> t
                                        type 'a shape
                                        val shape : t -> unit shape
                                        val from_shape : 'a shape -> t
                                        val fold2_join_heterogeneous :
                                          cache:Hptmap_sig.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
                                        val pretty_debug :
                                          t Pretty_utils.formatter
                                      end->
      sig
        module O :
          sig
            type t = Set.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 = Set.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 = 'Set.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 = 'Set.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 action =
              Set.action =
                Neutral
              | Absorbing
              | Traversing of (elt -> bool)
            val merge :
              cache:Hptmap_sig.cache_type ->
              symmetric:bool ->
              idempotent:bool ->
              decide_both:(elt -> bool) ->
              decide_left:action -> decide_right:action -> t -> t -> t
            type 'a shape = 'Set.shape
            val shape : t -> unit shape
            val from_shape : 'a shape -> t
            val fold2_join_heterogeneous :
              cache:Hptmap_sig.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
            val pretty_debug : t Pretty_utils.formatter
          end
        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 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 filter : (O.elt -> bool) -> t -> t
        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 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 t = t1 * t2
        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 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 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