sig
  module type InputDomain =
    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 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 top : t
      val join : t -> t -> t
    end
  module type LeafDomain =
    sig
      type t
      val backward_location :
        Domain_builder.LeafDomain.t ->
        Cil_types.lval ->
        Cil_types.typ -> 'loc -> '-> ('loc * 'v) Eval.or_bottom
      val reduce_further :
        Domain_builder.LeafDomain.t ->
        Cil_types.exp -> '-> (Cil_types.exp * 'v) list
      val evaluate_predicate :
        Domain_builder.LeafDomain.t Abstract_domain.logic_environment ->
        Domain_builder.LeafDomain.t -> Cil_types.predicate -> Alarmset.status
      val reduce_by_predicate :
        Domain_builder.LeafDomain.t Abstract_domain.logic_environment ->
        Domain_builder.LeafDomain.t ->
        Cil_types.predicate ->
        bool -> Domain_builder.LeafDomain.t Eval.or_bottom
      val interpret_acsl_extension :
        Cil_types.acsl_extension ->
        Domain_builder.LeafDomain.t Abstract_domain.logic_environment ->
        Domain_builder.LeafDomain.t -> Domain_builder.LeafDomain.t
      val enter_loop :
        Cil_types.stmt ->
        Domain_builder.LeafDomain.t -> Domain_builder.LeafDomain.t
      val incr_loop_counter :
        Cil_types.stmt ->
        Domain_builder.LeafDomain.t -> Domain_builder.LeafDomain.t
      val leave_loop :
        Cil_types.stmt ->
        Domain_builder.LeafDomain.t -> Domain_builder.LeafDomain.t
      val filter :
        Cil_types.kernel_function ->
        [ `Post | `Pre ] ->
        Base.Hptset.t ->
        Domain_builder.LeafDomain.t -> Domain_builder.LeafDomain.t
      val reuse :
        Cil_types.kernel_function ->
        Base.Hptset.t ->
        current_input:Domain_builder.LeafDomain.t ->
        previous_output:Domain_builder.LeafDomain.t ->
        Domain_builder.LeafDomain.t
      val show_expr :
        '->
        Domain_builder.LeafDomain.t ->
        Stdlib.Format.formatter -> Cil_types.exp -> unit
      val post_analysis :
        Domain_builder.LeafDomain.t Lattice_bounds.or_bottom -> unit
      module Store :
        sig
          val register_global_state : bool -> t Eval.or_bottom -> unit
          val register_initial_state : Value_types.callstack -> t -> unit
          val register_state_before_stmt :
            Value_types.callstack -> Cil_types.stmt -> t -> unit
          val register_state_after_stmt :
            Value_types.callstack -> Cil_types.stmt -> t -> unit
          val get_global_state : unit -> t Eval.or_bottom
          val get_initial_state :
            Cil_types.kernel_function -> t Eval.or_bottom
          val get_initial_state_by_callstack :
            ?selection:Eval.callstack list ->
            Cil_types.kernel_function ->
            t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
          val get_stmt_state :
            after:bool -> Cil_types.stmt -> t Eval.or_bottom
          val get_stmt_state_by_callstack :
            ?selection:Eval.callstack list ->
            after:bool ->
            Cil_types.stmt ->
            t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
          val mark_as_computed : unit -> unit
          val is_computed : unit -> bool
        end
      val key : Domain_builder.LeafDomain.t Abstract_domain.key
    end
  module Complete :
    functor (Domain : InputDomain->
      sig
        val backward_location :
          Domain.t ->
          Cil_types.lval ->
          Cil_types.typ -> 'loc -> '-> ('loc * 'v) Eval.or_bottom
        val reduce_further :
          Domain.t -> Cil_types.exp -> '-> (Cil_types.exp * 'v) list
        val evaluate_predicate :
          Domain.t Abstract_domain.logic_environment ->
          Domain.t -> Cil_types.predicate -> Alarmset.status
        val reduce_by_predicate :
          Domain.t Abstract_domain.logic_environment ->
          Domain.t -> Cil_types.predicate -> bool -> Domain.t Eval.or_bottom
        val interpret_acsl_extension :
          Cil_types.acsl_extension ->
          Domain.t Abstract_domain.logic_environment -> Domain.t -> Domain.t
        val enter_loop : Cil_types.stmt -> Domain.t -> Domain.t
        val incr_loop_counter : Cil_types.stmt -> Domain.t -> Domain.t
        val leave_loop : Cil_types.stmt -> Domain.t -> Domain.t
        val filter :
          Cil_types.kernel_function ->
          [ `Post | `Pre ] -> Base.Hptset.t -> Domain.t -> Domain.t
        val reuse :
          Cil_types.kernel_function ->
          Base.Hptset.t ->
          current_input:Domain.t -> previous_output:Domain.t -> Domain.t
        val show_expr :
          '-> Domain.t -> Format.formatter -> Cil_types.exp -> unit
        val post_analysis : Domain.t Lattice_bounds.or_bottom -> unit
        module Store :
          sig
            val register_global_state :
              bool -> Domain.t Eval.or_bottom -> unit
            val register_initial_state :
              Value_types.callstack -> Domain.t -> unit
            val register_state_before_stmt :
              Value_types.callstack -> Cil_types.stmt -> Domain.t -> unit
            val register_state_after_stmt :
              Value_types.callstack -> Cil_types.stmt -> Domain.t -> unit
            val get_global_state : unit -> Domain.t Eval.or_bottom
            val get_initial_state :
              Cil_types.kernel_function -> Domain.t Eval.or_bottom
            val get_initial_state_by_callstack :
              ?selection:Eval.callstack list ->
              Cil_types.kernel_function ->
              Domain.t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val get_stmt_state :
              after:bool -> Cil_types.stmt -> Domain.t Eval.or_bottom
            val get_stmt_state_by_callstack :
              ?selection:Eval.callstack list ->
              after:bool ->
              Cil_types.stmt ->
              Domain.t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val mark_as_computed : unit -> unit
            val is_computed : unit -> bool
          end
        val key : Domain.t Abstract_domain.key
      end
  module Complete_Minimal :
    functor (Value : Abstract_value.S) (Location : Abstract_location.S)
      (Domain : Simpler_domains.Minimal->
      sig
        type state = Domain.t
        type t = state
        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 disjoint : t -> t -> bool
            val diff : t -> t -> t
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            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 filter_map : (elt -> elt option) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_list : elt list -> t
            val to_seq_from : elt -> t -> elt Seq.t
            val to_seq : t -> elt Seq.t
            val to_rev_seq : t -> elt Seq.t
            val add_seq : elt Seq.t -> t -> t
            val of_seq : elt Seq.t -> t
            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 update : key -> ('a option -> 'a option) -> '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 union :
              (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_rev_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
            val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
            val of_seq : (key * 'a) Seq.t -> 'a 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 filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'Seq.t
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            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 find_opt : 'a t -> key -> 'a option
            val find_def : 'a t -> key -> '-> 'a
            val memo : 'a t -> key -> (key -> 'a) -> 'a
            val structural_descr : Structural_descr.t -> Structural_descr.t
            val make_type : 'Type.t -> 'a t Type.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
        val top : t
        val is_included : t -> t -> bool
        val join : t -> t -> t
        val widen :
          Cil_types.kernel_function -> Cil_types.stmt -> t -> t -> t
        val narrow : t -> t -> t Eval.or_bottom
        type value = Value.t
        type location = Location.location
        type origin
        val extract_expr :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t -> Cil_types.exp -> (value * origin option) Eval.evaluated
        val extract_lval :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t ->
          Cil_types.lval ->
          Cil_types.typ -> location -> (value * origin option) Eval.evaluated
        val backward_location :
          t ->
          Cil_types.lval ->
          Cil_types.typ ->
          location -> value -> (location * value) Eval.or_bottom
        val reduce_further :
          t -> Cil_types.exp -> value -> (Cil_types.exp * value) list
        val update :
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assign :
          Cil_types.kinstr ->
          location Eval.left_value ->
          Cil_types.exp ->
          (location, value) Eval.assigned ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assume :
          Cil_types.stmt ->
          Cil_types.exp ->
          bool ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val start_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val finalize_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option -> pre:t -> post:t -> t Eval.or_bottom
        val show_expr :
          (value, location, origin) Abstract_domain.valuation ->
          t -> Format.formatter -> Cil_types.exp -> unit
        val logic_assign :
          (location Eval.logic_assign * state) option ->
          location -> state -> state
        val evaluate_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> Alarmset.status
        val reduce_by_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> bool -> state Eval.or_bottom
        val interpret_acsl_extension :
          Cil_types.acsl_extension ->
          state Abstract_domain.logic_environment -> state -> state
        val enter_scope :
          Abstract_domain.variable_kind -> Cil_types.varinfo list -> t -> t
        val leave_scope :
          Cil_types.kernel_function -> Cil_types.varinfo list -> t -> t
        val empty : unit -> t
        val initialize_variable :
          Cil_types.lval ->
          location ->
          initialized:bool -> Abstract_domain.init_value -> t -> t
        val initialize_variable_using_type :
          Abstract_domain.variable_kind -> Cil_types.varinfo -> t -> t
        val enter_loop : Cil_types.stmt -> state -> state
        val incr_loop_counter : Cil_types.stmt -> state -> state
        val leave_loop : Cil_types.stmt -> state -> state
        val relate :
          Cil_types.kernel_function ->
          Base.Hptset.t -> t -> Base.SetLattice.t
        val filter :
          Cil_types.kernel_function ->
          [ `Post | `Pre ] -> Base.Hptset.t -> t -> t
        val reuse :
          Cil_types.kernel_function ->
          Base.Hptset.t -> current_input:t -> previous_output:t -> t
        val log_category : Self.category
        val post_analysis : t Eval.or_bottom -> unit
        module Store :
          sig
            val register_global_state : bool -> t Eval.or_bottom -> unit
            val register_initial_state : Value_types.callstack -> t -> unit
            val register_state_before_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val register_state_after_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val get_global_state : unit -> t Eval.or_bottom
            val get_initial_state :
              Cil_types.kernel_function -> t Eval.or_bottom
            val get_initial_state_by_callstack :
              ?selection:Eval.callstack list ->
              Cil_types.kernel_function ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val get_stmt_state :
              after:bool -> Cil_types.stmt -> t Eval.or_bottom
            val get_stmt_state_by_callstack :
              ?selection:Eval.callstack list ->
              after:bool ->
              Cil_types.stmt ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val mark_as_computed : unit -> unit
            val is_computed : unit -> bool
          end
        val key : t Abstract_domain.key
      end
  module Complete_Minimal_with_datatype :
    functor (Value : Abstract_value.S) (Location : Abstract_location.S)
      (Domain : Simpler_domains.Minimal_with_datatype->
      sig
        type state = Domain.t
        type t = state
        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 disjoint : t -> t -> bool
            val diff : t -> t -> t
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            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 filter_map : (elt -> elt option) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_list : elt list -> t
            val to_seq_from : elt -> t -> elt Seq.t
            val to_seq : t -> elt Seq.t
            val to_rev_seq : t -> elt Seq.t
            val add_seq : elt Seq.t -> t -> t
            val of_seq : elt Seq.t -> t
            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 update : key -> ('a option -> 'a option) -> '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 union :
              (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_rev_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
            val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
            val of_seq : (key * 'a) Seq.t -> 'a 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 filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'Seq.t
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            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 find_opt : 'a t -> key -> 'a option
            val find_def : 'a t -> key -> '-> 'a
            val memo : 'a t -> key -> (key -> 'a) -> 'a
            val structural_descr : Structural_descr.t -> Structural_descr.t
            val make_type : 'Type.t -> 'a t Type.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
        val top : t
        val is_included : t -> t -> bool
        val join : t -> t -> t
        val widen :
          Cil_types.kernel_function -> Cil_types.stmt -> t -> t -> t
        val narrow : t -> t -> t Eval.or_bottom
        type value = Value.t
        type location = Location.location
        type origin
        val extract_expr :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t -> Cil_types.exp -> (value * origin option) Eval.evaluated
        val extract_lval :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t ->
          Cil_types.lval ->
          Cil_types.typ -> location -> (value * origin option) Eval.evaluated
        val backward_location :
          t ->
          Cil_types.lval ->
          Cil_types.typ ->
          location -> value -> (location * value) Eval.or_bottom
        val reduce_further :
          t -> Cil_types.exp -> value -> (Cil_types.exp * value) list
        val update :
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assign :
          Cil_types.kinstr ->
          location Eval.left_value ->
          Cil_types.exp ->
          (location, value) Eval.assigned ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assume :
          Cil_types.stmt ->
          Cil_types.exp ->
          bool ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val start_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val finalize_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option -> pre:t -> post:t -> t Eval.or_bottom
        val show_expr :
          (value, location, origin) Abstract_domain.valuation ->
          t -> Format.formatter -> Cil_types.exp -> unit
        val logic_assign :
          (location Eval.logic_assign * state) option ->
          location -> state -> state
        val evaluate_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> Alarmset.status
        val reduce_by_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> bool -> state Eval.or_bottom
        val interpret_acsl_extension :
          Cil_types.acsl_extension ->
          state Abstract_domain.logic_environment -> state -> state
        val enter_scope :
          Abstract_domain.variable_kind -> Cil_types.varinfo list -> t -> t
        val leave_scope :
          Cil_types.kernel_function -> Cil_types.varinfo list -> t -> t
        val empty : unit -> t
        val initialize_variable :
          Cil_types.lval ->
          location ->
          initialized:bool -> Abstract_domain.init_value -> t -> t
        val initialize_variable_using_type :
          Abstract_domain.variable_kind -> Cil_types.varinfo -> t -> t
        val enter_loop : Cil_types.stmt -> state -> state
        val incr_loop_counter : Cil_types.stmt -> state -> state
        val leave_loop : Cil_types.stmt -> state -> state
        val relate :
          Cil_types.kernel_function ->
          Base.Hptset.t -> t -> Base.SetLattice.t
        val filter :
          Cil_types.kernel_function ->
          [ `Post | `Pre ] -> Base.Hptset.t -> t -> t
        val reuse :
          Cil_types.kernel_function ->
          Base.Hptset.t -> current_input:t -> previous_output:t -> t
        val log_category : Self.category
        val post_analysis : t Eval.or_bottom -> unit
        module Store :
          sig
            val register_global_state : bool -> t Eval.or_bottom -> unit
            val register_initial_state : Value_types.callstack -> t -> unit
            val register_state_before_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val register_state_after_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val get_global_state : unit -> t Eval.or_bottom
            val get_initial_state :
              Cil_types.kernel_function -> t Eval.or_bottom
            val get_initial_state_by_callstack :
              ?selection:Eval.callstack list ->
              Cil_types.kernel_function ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val get_stmt_state :
              after:bool -> Cil_types.stmt -> t Eval.or_bottom
            val get_stmt_state_by_callstack :
              ?selection:Eval.callstack list ->
              after:bool ->
              Cil_types.stmt ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val mark_as_computed : unit -> unit
            val is_computed : unit -> bool
          end
        val key : t Abstract_domain.key
      end
  module Complete_Simple_Cvalue :
    functor (Domain : Simpler_domains.Simple_Cvalue->
      sig
        type state = Domain.t
        type t = state
        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 disjoint : t -> t -> bool
            val diff : t -> t -> t
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            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 filter_map : (elt -> elt option) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_list : elt list -> t
            val to_seq_from : elt -> t -> elt Seq.t
            val to_seq : t -> elt Seq.t
            val to_rev_seq : t -> elt Seq.t
            val add_seq : elt Seq.t -> t -> t
            val of_seq : elt Seq.t -> t
            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 update : key -> ('a option -> 'a option) -> '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 union :
              (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_rev_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
            val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
            val of_seq : (key * 'a) Seq.t -> 'a 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 filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'Seq.t
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            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 find_opt : 'a t -> key -> 'a option
            val find_def : 'a t -> key -> '-> 'a
            val memo : 'a t -> key -> (key -> 'a) -> 'a
            val structural_descr : Structural_descr.t -> Structural_descr.t
            val make_type : 'Type.t -> 'a t Type.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
        val top : t
        val is_included : t -> t -> bool
        val join : t -> t -> t
        val widen :
          Cil_types.kernel_function -> Cil_types.stmt -> t -> t -> t
        val narrow : t -> t -> t Eval.or_bottom
        type value = Cvalue.V.t
        type location = Precise_locs.precise_location
        type origin
        val extract_expr :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t -> Cil_types.exp -> (value * origin option) Eval.evaluated
        val extract_lval :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t ->
          Cil_types.lval ->
          Cil_types.typ -> location -> (value * origin option) Eval.evaluated
        val backward_location :
          t ->
          Cil_types.lval ->
          Cil_types.typ ->
          location -> value -> (location * value) Eval.or_bottom
        val reduce_further :
          t -> Cil_types.exp -> value -> (Cil_types.exp * value) list
        val update :
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assign :
          Cil_types.kinstr ->
          location Eval.left_value ->
          Cil_types.exp ->
          (location, value) Eval.assigned ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assume :
          Cil_types.stmt ->
          Cil_types.exp ->
          bool ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val start_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val finalize_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option -> pre:t -> post:t -> t Eval.or_bottom
        val show_expr :
          (value, location, origin) Abstract_domain.valuation ->
          t -> Format.formatter -> Cil_types.exp -> unit
        val logic_assign :
          (location Eval.logic_assign * state) option ->
          location -> state -> state
        val evaluate_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> Alarmset.status
        val reduce_by_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> bool -> state Eval.or_bottom
        val interpret_acsl_extension :
          Cil_types.acsl_extension ->
          state Abstract_domain.logic_environment -> state -> state
        val enter_scope :
          Abstract_domain.variable_kind -> Cil_types.varinfo list -> t -> t
        val leave_scope :
          Cil_types.kernel_function -> Cil_types.varinfo list -> t -> t
        val empty : unit -> t
        val initialize_variable :
          Cil_types.lval ->
          location ->
          initialized:bool -> Abstract_domain.init_value -> t -> t
        val initialize_variable_using_type :
          Abstract_domain.variable_kind -> Cil_types.varinfo -> t -> t
        val enter_loop : Cil_types.stmt -> state -> state
        val incr_loop_counter : Cil_types.stmt -> state -> state
        val leave_loop : Cil_types.stmt -> state -> state
        val relate :
          Cil_types.kernel_function ->
          Base.Hptset.t -> t -> Base.SetLattice.t
        val filter :
          Cil_types.kernel_function ->
          [ `Post | `Pre ] -> Base.Hptset.t -> t -> t
        val reuse :
          Cil_types.kernel_function ->
          Base.Hptset.t -> current_input:t -> previous_output:t -> t
        val log_category : Self.category
        val post_analysis : t Eval.or_bottom -> unit
        module Store :
          sig
            val register_global_state : bool -> t Eval.or_bottom -> unit
            val register_initial_state : Value_types.callstack -> t -> unit
            val register_state_before_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val register_state_after_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val get_global_state : unit -> t Eval.or_bottom
            val get_initial_state :
              Cil_types.kernel_function -> t Eval.or_bottom
            val get_initial_state_by_callstack :
              ?selection:Eval.callstack list ->
              Cil_types.kernel_function ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val get_stmt_state :
              after:bool -> Cil_types.stmt -> t Eval.or_bottom
            val get_stmt_state_by_callstack :
              ?selection:Eval.callstack list ->
              after:bool ->
              Cil_types.stmt ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val mark_as_computed : unit -> unit
            val is_computed : unit -> bool
          end
        val key : t Abstract_domain.key
      end
  module Restrict :
    functor (Value : Abstract_value.S)
      (Domain : sig
                  type state
                  type t = state
                  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 disjoint : t -> t -> bool
                      val diff : t -> t -> t
                      val subset : t -> t -> bool
                      val iter : (elt -> unit) -> t -> unit
                      val map : (elt -> elt) -> t -> t
                      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 filter_map : (elt -> elt option) -> t -> t
                      val partition : (elt -> bool) -> t -> t * t
                      val cardinal : t -> int
                      val elements : t -> elt list
                      val min_elt : t -> elt
                      val min_elt_opt : t -> elt option
                      val max_elt : t -> elt
                      val max_elt_opt : t -> elt option
                      val choose : t -> elt
                      val choose_opt : t -> elt option
                      val split : elt -> t -> t * bool * t
                      val find : elt -> t -> elt
                      val find_opt : elt -> t -> elt option
                      val find_first : (elt -> bool) -> t -> elt
                      val find_first_opt : (elt -> bool) -> t -> elt option
                      val find_last : (elt -> bool) -> t -> elt
                      val find_last_opt : (elt -> bool) -> t -> elt option
                      val of_list : elt list -> t
                      val to_seq_from : elt -> t -> elt Seq.t
                      val to_seq : t -> elt Seq.t
                      val to_rev_seq : t -> elt Seq.t
                      val add_seq : elt Seq.t -> t -> t
                      val of_seq : elt Seq.t -> t
                      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 update :
                        key -> ('a option -> 'a option) -> '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 union :
                        (key -> '-> '-> 'a option) ->
                        'a t -> 'a t -> 'a 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 filter_map :
                        (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
                      val max_binding : 'a t -> key * 'a
                      val max_binding_opt : 'a t -> (key * 'a) option
                      val choose : 'a t -> key * 'a
                      val choose_opt : 'a t -> (key * 'a) option
                      val split : key -> 'a t -> 'a t * 'a option * 'a t
                      val find : key -> 'a t -> 'a
                      val find_opt : key -> 'a t -> 'a option
                      val find_first : (key -> bool) -> 'a t -> key * 'a
                      val find_first_opt :
                        (key -> bool) -> 'a t -> (key * 'a) option
                      val find_last : (key -> bool) -> 'a t -> key * 'a
                      val find_last_opt :
                        (key -> bool) -> 'a t -> (key * 'a) option
                      val map : ('-> 'b) -> 'a t -> 'b t
                      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                      val to_seq : 'a t -> (key * 'a) Seq.t
                      val to_rev_seq : 'a t -> (key * 'a) Seq.t
                      val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
                      val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
                      val of_seq : (key * 'a) Seq.t -> 'a 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 filter_map_inplace :
                        (key -> '-> 'a option) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                      val stats : 'a t -> Hashtbl.statistics
                      val to_seq : 'a t -> (key * 'a) Seq.t
                      val to_seq_keys : 'a t -> key Seq.t
                      val to_seq_values : 'a t -> 'Seq.t
                      val add_seq : 'a t -> (key * 'a) Seq.t -> unit
                      val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
                      val of_seq : (key * 'a) Seq.t -> 'a t
                      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 find_opt : 'a t -> key -> 'a option
                      val find_def : 'a t -> key -> '-> 'a
                      val memo : 'a t -> key -> (key -> 'a) -> 'a
                      val structural_descr :
                        Structural_descr.t -> Structural_descr.t
                      val make_type : 'Type.t -> 'a t Type.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
                  val top : t
                  val is_included : t -> t -> bool
                  val join : t -> t -> t
                  val widen :
                    Cil_types.kernel_function ->
                    Cil_types.stmt -> t -> t -> t
                  val narrow : t -> t -> t Eval.or_bottom
                  type value = Value.t
                  type location
                  type origin
                  val extract_expr :
                    oracle:(Cil_types.exp -> value Eval.evaluated) ->
                    Abstract_domain.evaluation_context ->
                    t ->
                    Cil_types.exp -> (value * origin option) Eval.evaluated
                  val extract_lval :
                    oracle:(Cil_types.exp -> value Eval.evaluated) ->
                    Abstract_domain.evaluation_context ->
                    t ->
                    Cil_types.lval ->
                    Cil_types.typ ->
                    location -> (value * origin option) Eval.evaluated
                  val backward_location :
                    t ->
                    Cil_types.lval ->
                    Cil_types.typ ->
                    location -> value -> (location * value) Eval.or_bottom
                  val reduce_further :
                    t ->
                    Cil_types.exp -> value -> (Cil_types.exp * value) list
                  val update :
                    (value, location, origin) Abstract_domain.valuation ->
                    t -> t Eval.or_bottom
                  val assign :
                    Cil_types.kinstr ->
                    location Eval.left_value ->
                    Cil_types.exp ->
                    (location, value) Eval.assigned ->
                    (value, location, origin) Abstract_domain.valuation ->
                    t -> t Eval.or_bottom
                  val assume :
                    Cil_types.stmt ->
                    Cil_types.exp ->
                    bool ->
                    (value, location, origin) Abstract_domain.valuation ->
                    t -> t Eval.or_bottom
                  val start_call :
                    Cil_types.stmt ->
                    (location, value) Eval.call ->
                    Eval.recursion option ->
                    (value, location, origin) Abstract_domain.valuation ->
                    t -> t Eval.or_bottom
                  val finalize_call :
                    Cil_types.stmt ->
                    (location, value) Eval.call ->
                    Eval.recursion option ->
                    pre:t -> post:t -> t Eval.or_bottom
                  val show_expr :
                    (value, location, origin) Abstract_domain.valuation ->
                    t -> Format.formatter -> Cil_types.exp -> unit
                  val logic_assign :
                    (location Eval.logic_assign * state) option ->
                    location -> state -> state
                  val evaluate_predicate :
                    state Abstract_domain.logic_environment ->
                    state -> Cil_types.predicate -> Alarmset.status
                  val reduce_by_predicate :
                    state Abstract_domain.logic_environment ->
                    state ->
                    Cil_types.predicate -> bool -> state Eval.or_bottom
                  val interpret_acsl_extension :
                    Cil_types.acsl_extension ->
                    state Abstract_domain.logic_environment -> state -> state
                  val enter_scope :
                    Abstract_domain.variable_kind ->
                    Cil_types.varinfo list -> t -> t
                  val leave_scope :
                    Cil_types.kernel_function ->
                    Cil_types.varinfo list -> t -> t
                  val empty : unit -> t
                  val initialize_variable :
                    Cil_types.lval ->
                    location ->
                    initialized:bool -> Abstract_domain.init_value -> t -> t
                  val initialize_variable_using_type :
                    Abstract_domain.variable_kind ->
                    Cil_types.varinfo -> t -> t
                  val enter_loop : Cil_types.stmt -> state -> state
                  val incr_loop_counter : Cil_types.stmt -> state -> state
                  val leave_loop : Cil_types.stmt -> state -> state
                  val relate :
                    Cil_types.kernel_function ->
                    Base.Hptset.t -> t -> Base.SetLattice.t
                  val filter :
                    Cil_types.kernel_function ->
                    [ `Post | `Pre ] -> Base.Hptset.t -> t -> t
                  val reuse :
                    Cil_types.kernel_function ->
                    Base.Hptset.t ->
                    current_input:t -> previous_output:t -> t
                  val log_category : Self.category
                  val post_analysis : t Eval.or_bottom -> unit
                  module Store :
                    sig
                      val register_global_state :
                        bool -> t Eval.or_bottom -> unit
                      val register_initial_state :
                        Value_types.callstack -> t -> unit
                      val register_state_before_stmt :
                        Value_types.callstack -> Cil_types.stmt -> t -> unit
                      val register_state_after_stmt :
                        Value_types.callstack -> Cil_types.stmt -> t -> unit
                      val get_global_state : unit -> t Eval.or_bottom
                      val get_initial_state :
                        Cil_types.kernel_function -> t Eval.or_bottom
                      val get_initial_state_by_callstack :
                        ?selection:Eval.callstack list ->
                        Cil_types.kernel_function ->
                        t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
                      val get_stmt_state :
                        after:bool -> Cil_types.stmt -> t Eval.or_bottom
                      val get_stmt_state_by_callstack :
                        ?selection:Eval.callstack list ->
                        after:bool ->
                        Cil_types.stmt ->
                        t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
                      val mark_as_computed : unit -> unit
                      val is_computed : unit -> bool
                    end
                  val structure : t Abstract.Domain.structure
                end)
      (Scope : sig val functions : Domain_mode.function_mode list end->
      sig
        type state
        type t = state
        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 disjoint : t -> t -> bool
            val diff : t -> t -> t
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            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 filter_map : (elt -> elt option) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_list : elt list -> t
            val to_seq_from : elt -> t -> elt Seq.t
            val to_seq : t -> elt Seq.t
            val to_rev_seq : t -> elt Seq.t
            val add_seq : elt Seq.t -> t -> t
            val of_seq : elt Seq.t -> t
            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 update : key -> ('a option -> 'a option) -> '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 union :
              (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_rev_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
            val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
            val of_seq : (key * 'a) Seq.t -> 'a 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 filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'Seq.t
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            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 find_opt : 'a t -> key -> 'a option
            val find_def : 'a t -> key -> '-> 'a
            val memo : 'a t -> key -> (key -> 'a) -> 'a
            val structural_descr : Structural_descr.t -> Structural_descr.t
            val make_type : 'Type.t -> 'a t Type.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
        val top : t
        val is_included : t -> t -> bool
        val join : t -> t -> t
        val widen :
          Cil_types.kernel_function -> Cil_types.stmt -> t -> t -> t
        val narrow : t -> t -> t Eval.or_bottom
        type value = Value.t
        type location = Domain.location
        type origin
        val extract_expr :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t -> Cil_types.exp -> (value * origin option) Eval.evaluated
        val extract_lval :
          oracle:(Cil_types.exp -> value Eval.evaluated) ->
          Abstract_domain.evaluation_context ->
          t ->
          Cil_types.lval ->
          Cil_types.typ -> location -> (value * origin option) Eval.evaluated
        val backward_location :
          t ->
          Cil_types.lval ->
          Cil_types.typ ->
          location -> value -> (location * value) Eval.or_bottom
        val reduce_further :
          t -> Cil_types.exp -> value -> (Cil_types.exp * value) list
        val update :
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assign :
          Cil_types.kinstr ->
          location Eval.left_value ->
          Cil_types.exp ->
          (location, value) Eval.assigned ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val assume :
          Cil_types.stmt ->
          Cil_types.exp ->
          bool ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val start_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option ->
          (value, location, origin) Abstract_domain.valuation ->
          t -> t Eval.or_bottom
        val finalize_call :
          Cil_types.stmt ->
          (location, value) Eval.call ->
          Eval.recursion option -> pre:t -> post:t -> t Eval.or_bottom
        val show_expr :
          (value, location, origin) Abstract_domain.valuation ->
          t -> Format.formatter -> Cil_types.exp -> unit
        val logic_assign :
          (location Eval.logic_assign * state) option ->
          location -> state -> state
        val evaluate_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> Alarmset.status
        val reduce_by_predicate :
          state Abstract_domain.logic_environment ->
          state -> Cil_types.predicate -> bool -> state Eval.or_bottom
        val interpret_acsl_extension :
          Cil_types.acsl_extension ->
          state Abstract_domain.logic_environment -> state -> state
        val enter_scope :
          Abstract_domain.variable_kind -> Cil_types.varinfo list -> t -> t
        val leave_scope :
          Cil_types.kernel_function -> Cil_types.varinfo list -> t -> t
        val empty : unit -> t
        val initialize_variable :
          Cil_types.lval ->
          location ->
          initialized:bool -> Abstract_domain.init_value -> t -> t
        val initialize_variable_using_type :
          Abstract_domain.variable_kind -> Cil_types.varinfo -> t -> t
        val enter_loop : Cil_types.stmt -> state -> state
        val incr_loop_counter : Cil_types.stmt -> state -> state
        val leave_loop : Cil_types.stmt -> state -> state
        val relate :
          Cil_types.kernel_function ->
          Base.Hptset.t -> t -> Base.SetLattice.t
        val filter :
          Cil_types.kernel_function ->
          [ `Post | `Pre ] -> Base.Hptset.t -> t -> t
        val reuse :
          Cil_types.kernel_function ->
          Base.Hptset.t -> current_input:t -> previous_output:t -> t
        val log_category : Self.category
        val post_analysis : t Eval.or_bottom -> unit
        module Store :
          sig
            val register_global_state : bool -> t Eval.or_bottom -> unit
            val register_initial_state : Value_types.callstack -> t -> unit
            val register_state_before_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val register_state_after_stmt :
              Value_types.callstack -> Cil_types.stmt -> t -> unit
            val get_global_state : unit -> t Eval.or_bottom
            val get_initial_state :
              Cil_types.kernel_function -> t Eval.or_bottom
            val get_initial_state_by_callstack :
              ?selection:Eval.callstack list ->
              Cil_types.kernel_function ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val get_stmt_state :
              after:bool -> Cil_types.stmt -> t Eval.or_bottom
            val get_stmt_state_by_callstack :
              ?selection:Eval.callstack list ->
              after:bool ->
              Cil_types.stmt ->
              t Value_types.Callstack.Hashtbl.t Eval.or_top_bottom
            val mark_as_computed : unit -> unit
            val is_computed : unit -> bool
          end
        val structure : t Abstract.Domain.structure
      end
end