functor (S : Lattice.S->
  sig
    module L :
      sig
        type t1 = S.t
        type t2 = S.t
        type tt = private Product of t1 * t2 | Bottom
        exception Error_Top
        exception Error_Bottom
        type t = tt
        type widen_hint
        val equal : t -> t -> bool
        val join : t -> t -> t
        val link : t -> t -> t
        val meet : t -> t -> t
        val narrow : t -> t -> t
        val bottom : t
        val top : t
        val is_included : t -> t -> bool
        val is_included_exn : t -> t -> unit
        val intersects : t -> t -> bool
        val pretty : Format.formatter -> t -> unit
        val widen : widen_hint -> t -> t -> t
        val cardinal_zero_or_one : t -> bool
        val cardinal_less_than : t -> int -> int
        val tag : t -> int
        module Datatype :
          sig
            type t = t
            val rehash : t -> t
            val descr : Unmarshal.t
            val copy : t -> t
            val name : string
            val register_comparable :
              ?compare:(t -> t -> int) ->
              ?equal:(t -> t -> bool) ->
              ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
            val is_comparable_set : unit -> bool
            val hash : t -> int
            val physical_hash : t -> int
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val contain_project : (Project.project -> t -> bool) option ref
          end
        val inject : t1 -> t2 -> t
        val fst : t -> t1
        val snd : t -> t2
        val filterAnnotations : Cil_types.attribute list -> S.annotation list
        val attributes2state : S.t -> Cil_types.attribute list -> S.t
        val type_attributes2state : S.t -> Cil_types.typ -> S.t
        val defaultall : Base.t -> t
        val default : Base.t -> '-> '-> t
      end
    module Leaks :
      sig
        type call = { cloc : Cil_types.location; fname : string; }
        type leak = {
          potential : bool;
          loc : Cil_types.location option;
          data : Cil_types.exp;
          call_stack : Model.Make.Leaks.call list;
        }
        type t = Model.Make.Leaks.leak list
        val empty : 'a list
        val print_call_stack :
          Format.formatter -> Model.Make.Leaks.call list -> unit
        val print_leak : Model.Make.Leaks.leak -> unit
        val print_stat : int * int -> unit
        val nb_leaks : (int * int) Pervasives.ref
        val print : Model.Make.Leaks.leak list -> unit
        val print_all : Model.Make.Leaks.leak list -> unit
        val new_leak :
          bool ->
          Cil_types.location option -> Cil_types.exp -> Model.Make.Leaks.leak
        val add_leak :
          potential:bool ->
          Cil_types.location option ->
          Cil_types.exp ->
          Model.Make.Leaks.leak list -> Model.Make.Leaks.leak list
        val add_from_and_subst :
          Cil_types.location ->
          string ->
          Subst.t ->
          from:Model.Make.Leaks.leak list ->
          Model.Make.Leaks.leak list -> Model.Make.Leaks.leak list
        val is_included :
          Model.Make.Leaks.leak list -> Model.Make.Leaks.leak list -> bool
        val combine :
          old:Model.Make.Leaks.leak list ->
          Model.Make.Leaks.leak list -> Model.Make.Leaks.leak list
      end
    module State :
      sig
        module M :
          sig
            type y = L.t
            type t = Lmap_bitwise.Make_bitwise(L).t
            module Datatype :
              sig
                type t = t
                val rehash : t -> t
                val descr : Unmarshal.t
                val copy : t -> t
                val name : string
                val register_comparable :
                  ?compare:(t -> t -> int) ->
                  ?equal:(t -> t -> bool) ->
                  ?hash:(t -> int) ->
                  ?physical_hash:(t -> int) -> unit -> unit
                val is_comparable_set : unit -> bool
                val hash : t -> int
                val physical_hash : t -> int
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val contain_project :
                  (Project.project -> t -> bool) option ref
              end
            module LOffset :
              sig
                type t = Lmap_bitwise.Make_bitwise(L).LOffset.t
                val find_intervs :
                  (Abstract_interp.Int.t -> Abstract_interp.Int.t -> y) ->
                  Abstract_value.Int_Intervals.t -> t -> y
                val map : (bool * y -> bool * y) -> t -> t
                val fold :
                  (Abstract_value.Int_Intervals.t -> bool * y -> '-> 'a) ->
                  t -> '-> 'a
                val join : t -> t -> t
                val pretty : Format.formatter -> t -> unit
                val pretty_with_type :
                  Cil_types.typ option -> Format.formatter -> t -> unit
                val collapse : t -> y
                val empty : t
                val is_empty : t -> bool
                val add_iset :
                  exact:bool -> Abstract_value.Int_Intervals.t -> y -> t -> t
                val equal : t -> t -> bool
                val tag : t -> int
                module Datatype :
                  sig
                    type t = t
                    val rehash : t -> t
                    val descr : Unmarshal.t
                    val copy : t -> t
                    val name : string
                    val register_comparable :
                      ?compare:(t -> t -> int) ->
                      ?equal:(t -> t -> bool) ->
                      ?hash:(t -> int) ->
                      ?physical_hash:(t -> int) -> unit -> unit
                    val is_comparable_set : unit -> bool
                    val hash : t -> int
                    val physical_hash : t -> int
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val contain_project :
                      (Project.project -> t -> bool) option ref
                  end
              end
            val pretty : Format.formatter -> t -> unit
            val empty : t
            val join : t -> t -> t
            val equal : t -> t -> bool
            val hash : t -> int
            val is_included : t -> t -> bool
            val add_binding : exact:bool -> t -> Locations.Zone.t -> y -> t
            val map_and_merge : (y -> y) -> t -> t -> t
            val filter_base : (Base.t -> bool) -> t -> t
            val find : t -> Locations.Zone.t -> y
            val find_base : t -> Locations.Zone.t -> LOffset.t
            exception Cannot_fold
            val uninitialize_locals : Cil_types.varinfo list -> t -> t
            val fold :
              (Locations.Zone.t -> bool * y -> '-> 'a) -> t -> '-> 'a
            val fold_base :
              (Base.t -> LOffset.t -> '-> 'a) -> t -> '-> 'a
            val map2 :
              ((bool * y) option -> (bool * y) option -> bool * y) ->
              t -> t -> t
            val copy_paste :
              f:(bool * y -> bool * y) ->
              Locations.location -> Locations.location -> t -> t
            exception Zone_unchanged
            val find_or_unchanged : t -> Locations.Zone.t -> y
            val add_binding : t -> Locations.location -> y -> t
          end
        type t = {
          map : Model.Make.State.M.t;
          leaks : Model.Make.Leaks.t;
          subst : Subst.t;
        }
        val pretty : Format.formatter -> Model.Make.State.t -> unit
        val find_zone_status :
          Model.Make.State.t -> Locations.Zone.t -> Model.Make.State.M.y
        val find_loc_status :
          Model.Make.State.t -> Locations.location -> Model.Make.State.M.y
        val find_loc_status_with_deps :
          ?with_deps:bool ->
          Model.Make.State.t -> Locations.location -> Model.Make.L.t1
        type exp_status = Status of S.t | Location of Locations.location
        val pretty_status :
          Format.formatter -> Model.Make.State.exp_status -> unit
        val last_stmt : Cil_types.stmt Pervasives.ref
        type call = { current_fun : Db_types.kernel_function; deps : S.t; }
        val call_stack : Model.Make.State.call Stack.t
        val reset : unit -> Model.Make.State.t
        val lval_to_loc :
          Db.Value.state -> Cil_types.lval -> Locations.location
        val status_of_deps : Db.Value.state -> Model.Make.State.t -> S.t
        val join_deps : Db.Value.state -> Model.Make.State.t -> S.t -> S.t
        val find_loc_or_status :
          ?with_deps:bool ->
          Db.Value.state ->
          Model.Make.State.t -> Cil_types.exp -> Model.Make.State.exp_status
        val find_exp_status :
          ?with_deps:bool ->
          Db.Value.state ->
          Model.Make.State.t -> Cil_types.exp -> Model.Make.L.t1
        val is_included : Model.Make.State.t -> Model.Make.State.t -> bool
        val combine :
          old:Model.Make.State.t -> Model.Make.State.t -> Model.Make.State.t
        val change_loc_status :
          Db.Value.state ->
          Model.Make.State.t ->
          Locations.location ->
          Model.Make.State.exp_status -> Model.Make.State.t
        val change_lval_status :
          Db.Value.state ->
          Model.Make.State.t ->
          Cil_types.lval -> Model.Make.State.exp_status -> Model.Make.State.t
        val change_lval_exp :
          Db.Value.state ->
          Model.Make.State.t ->
          Cil_types.lval -> Cil_types.exp -> Model.Make.State.t
        val clear_leaks : Model.Make.State.t -> Model.Make.State.t
        val push_call :
          Db.Value.state ->
          Db_types.kernel_function ->
          Cil_types.exp list -> Model.Make.State.t -> Model.Make.State.t
        val pop_call :
          Cil_types.kinstr ->
          Cil_types.fundec ->
          Cil_types.exp list ->
          old:Model.Make.State.t -> Model.Make.State.t -> Model.Make.State.t
        val print_results : Model.Make.State.t -> unit
        val add_leak :
          potential:bool ->
          Model.Make.State.t ->
          Cil_types.kinstr -> Cil_types.exp -> Model.Make.State.t
      end
    module Register :
      sig
        val change_loc_status :
          Db.Value.state ->
          Model.Make.State.t ->
          Locations.location -> S.t -> Model.Make.State.t
        val typ :
          Model.Make.State.t ->
          Db.Value.state ->
          Locations.location -> Cil_types.typ -> Model.Make.State.t
        val field :
          Db.Value.state ->
          Cil_types.typ ->
          Locations.location ->
          Model.Make.State.t -> Cil_types.fieldinfo -> Model.Make.State.t
        val variable :
          Model.Make.State.t ->
          Db.Value.state ->
          ?status:S.t -> Cil_types.varinfo -> Model.Make.State.t
        val globals : Model.Make.State.t -> Model.Make.State.t
        val locals :
          Db.Value.state ->
          Cil_types.fundec -> Model.Make.State.t -> Model.Make.State.t
        val formals :
          Cil_types.varinfo list ->
          Cil_types.exp list ->
          Db.Value.state ->
          Model.Make.State.t -> Model.Make.State.t * Db.Value.state
        val clean :
          Kernel_function.t -> Model.Make.State.t -> Model.Make.State.t
      end
    module Logic :
      sig
        val affect :
          Db.Value.state ->
          Model.Make.State.t ->
          Cil_types.lval -> Cil_types.exp -> Model.Make.State.t
        val return :
          Db.Value.state ->
          Model.Make.State.t ->
          Cil_types.lval option -> Cil_types.exp -> Model.Make.State.t
        val equal : S.t -> S.t -> bool
        val comparable : S.t -> S.t -> bool
        val uncomparable : S.t -> S.t -> bool
        val cmp_of_rel : S.t -> S.t -> Cil_types.relation -> bool * bool
        val warn_todo : unit -> unit
        val find_term_loc_or_status :
          Db.Value.state ->
          Model.Make.State.t ->
          Cil_types.logic_info ->
          Cil_types.term list -> Model.Make.State.exp_status option
        val requires :
          Db.Value.state ->
          Cil_types.kinstr ->
          Model.Make.State.t ->
          Cil_types.predicate Cil_types.named -> Model.Make.State.t
        val ensures :
          Db.Value.state ->
          Model.Make.State.t ->
          Cil_types.predicate Cil_types.named -> Model.Make.State.t
      end
  end