sig
  val merge_call_in_local_table :
    CallsiteHash.key -> Inout_type.t CallsiteHash.t -> Inout_type.t -> unit
  val merge_call_in_global_tables :
    Operational_inputs.Internals.key * Cil_types.kinstr ->
    Inout_type.t -> unit
  val merge_local_table_in_global_ones : Inout_type.t CallsiteHash.t -> unit
  val call_inout_stack :
    (Operational_inputs.Internals.key * Inout_type.t CallsiteHash.t) list
    Stdlib.ref
  val call_for_callwise_inout :
    [< `Builtin of Value_types.call_result
     | `Def
     | `Memexec
     | `Spec of Cil_types.spec ] *
    Db.Value.state *
    (Operational_inputs.Internals.key * Cil_types.kinstr) list -> unit
  module MemExec :
    sig
      val self : State.t
      val name : string
      val mark_as_computed : ?project:Project.t -> unit -> unit
      val is_computed : ?project:Project.t -> unit -> bool
      module Datatype :
        sig
          type t = Inout_type.t Datatype.Int.Hashtbl.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
      val add_hook_on_update : (Datatype.t -> unit) -> unit
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type key = Datatype.Int.Hashtbl.key
      type data = Inout_type.t
      val replace : key -> data -> unit
      val add : key -> data -> unit
      val clear : unit -> unit
      val length : unit -> int
      val iter : (key -> data -> unit) -> unit
      val iter_sorted :
        ?cmp:(key -> key -> int) -> (key -> data -> unit) -> unit
      val fold : (key -> data -> '-> 'a) -> '-> 'a
      val fold_sorted :
        ?cmp:(key -> key -> int) -> (key -> data -> '-> 'a) -> '-> 'a
      val memo : ?change:(data -> data) -> (key -> data) -> key -> data
      val find : key -> data
      val find_all : key -> data list
      val mem : key -> bool
      val remove : key -> unit
    end
  val end_record :
    (Operational_inputs.Internals.key * Cil_types.kinstr) list ->
    Inout_type.t -> unit
  val compute_call_from_value_states :
    Cil_types.kernel_function ->
    Value_types.Callstack.Hashtbl.key ->
    Cvalue.Model.t Cil_datatype.Stmt.Hashtbl.t -> Operational_inputs.t
  val record_for_callwise_inout :
    Db.Value.callstack *
    (Cvalue.Model.t Cil_datatype.Stmt.Hashtbl.t Stdlib.Lazy.t * 'a)
    Value_types.callback_result -> unit
end