sig   module Location_Bytes :     sig       module M :         sig           type key = Base.t           type t           val iter :             (Base.t -> Ival.t -> unit) ->             Locations.Location_Bytes.M.t -> unit           val find :             Locations.Location_Bytes.M.key ->             Locations.Location_Bytes.M.t -> Ival.t           val fold :             (Base.t -> Ival.t -> '-> 'a) ->             Locations.Location_Bytes.M.t -> '-> 'a           val shape :             Locations.Location_Bytes.M.t -> Ival.t Hptmap.Shape(Base.Base).t         end       type t =           Top of Base.SetLattice.t * Origin.t         | Map of Locations.Location_Bytes.M.t       type size_widen_hint = Ival.size_widen_hint       type generic_widen_hint = Base.t -> Ival.generic_widen_hint       type widen_hint =           Locations.Location_Bytes.size_widen_hint *           Locations.Location_Bytes.generic_widen_hint       val join : t -> t -> t       val is_included : t -> t -> bool       val join_and_is_included : t -> t -> t * bool       val bottom : t       val top : t       val widen : widen_hint -> t -> t -> t       val narrow : t -> t -> t       val link : t -> t -> t       val meet : t -> t -> t       val intersects : t -> t -> bool       exception Error_Top       val ty : t Type.t       val name : string       val descr : t Descr.t       val packed_descr : Structural_descr.pack       val reprs : t list       val equal : t -> t -> bool       val compare : t -> t -> int       val hash : t -> int       val pretty_code : Format.formatter -> t -> unit       val internal_pretty_code :         Type.precedence -> Format.formatter -> t -> unit       val pretty : Format.formatter -> t -> unit       val varname : t -> string       val mem_project : (Project_skeleton.t -> bool) -> t -> bool       val copy : t -> t       module Set :         sig           type elt = t           type t           val empty : t           val is_empty : t -> bool           val mem : elt -> t -> bool           val add : elt -> t -> t           val singleton : elt -> t           val remove : elt -> t -> t           val union : t -> t -> t           val inter : t -> t -> t           val diff : t -> t -> t           val subset : t -> t -> bool           val iter : (elt -> unit) -> t -> unit           val fold : (elt -> '-> 'a) -> t -> '-> 'a           val for_all : (elt -> bool) -> t -> bool           val exists : (elt -> bool) -> t -> bool           val filter : (elt -> bool) -> t -> t           val partition : (elt -> bool) -> t -> t * t           val cardinal : t -> int           val elements : t -> elt list           val choose : t -> elt           val split : elt -> t -> t * bool * t           val find : elt -> t -> elt           val of_list : elt list -> t           val min_elt : t -> elt           val max_elt : t -> elt           val nearest_elt_le : elt -> t -> elt           val nearest_elt_ge : elt -> t -> elt           val ty : t Type.t           val name : string           val descr : t Descr.t           val packed_descr : Structural_descr.pack           val reprs : t list           val equal : t -> t -> bool           val compare : t -> t -> int           val hash : t -> int           val pretty_code : Format.formatter -> t -> unit           val internal_pretty_code :             Type.precedence -> Format.formatter -> t -> unit           val pretty : Format.formatter -> t -> unit           val varname : t -> string           val mem_project : (Project_skeleton.t -> bool) -> t -> bool           val copy : t -> t         end       module Map :         sig           type key = t           type +'a t           val empty : 'a t           val is_empty : 'a t -> bool           val mem : key -> 'a t -> bool           val add : key -> '-> 'a t -> 'a t           val singleton : key -> '-> 'a t           val remove : key -> 'a t -> 'a t           val merge :             (key -> 'a option -> 'b option -> 'c option) ->             'a t -> 'b t -> 'c t           val compare : ('-> '-> int) -> 'a t -> 'a t -> int           val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val for_all : (key -> '-> bool) -> 'a t -> bool           val exists : (key -> '-> bool) -> 'a t -> bool           val filter : (key -> '-> bool) -> 'a t -> 'a t           val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t           val cardinal : 'a t -> int           val bindings : 'a t -> (key * 'a) list           val min_binding : 'a t -> key * 'a           val max_binding : 'a t -> key * 'a           val choose : 'a t -> key * 'a           val split : key -> 'a t -> 'a t * 'a option * 'a t           val find : key -> 'a t -> 'a           val map : ('-> 'b) -> 'a t -> 'b t           val mapi : (key -> '-> 'b) -> 'a t -> 'b t           module Key :             sig               type t = key               val ty : t Type.t               val name : string               val descr : t Descr.t               val packed_descr : Structural_descr.pack               val reprs : t list               val equal : t -> t -> bool               val compare : t -> t -> int               val hash : t -> int               val pretty_code : Format.formatter -> t -> unit               val internal_pretty_code :                 Type.precedence -> Format.formatter -> t -> unit               val pretty : Format.formatter -> t -> unit               val varname : t -> string               val mem_project : (Project_skeleton.t -> bool) -> t -> bool               val copy : t -> t             end           module Make :             functor (Data : Datatype.S->               sig                 type t = Data.t t                 val ty : t Type.t                 val name : string                 val descr : t Descr.t                 val packed_descr : Structural_descr.pack                 val reprs : t list                 val equal : t -> t -> bool                 val compare : t -> t -> int                 val hash : t -> int                 val pretty_code : Format.formatter -> t -> unit                 val internal_pretty_code :                   Type.precedence -> Format.formatter -> t -> unit                 val pretty : Format.formatter -> t -> unit                 val varname : t -> string                 val mem_project : (Project_skeleton.t -> bool) -> t -> bool                 val copy : t -> t               end         end       module Hashtbl :         sig           type key = t           type 'a t           val create : int -> 'a t           val clear : 'a t -> unit           val reset : 'a t -> unit           val copy : 'a t -> 'a t           val add : 'a t -> key -> '-> unit           val remove : 'a t -> key -> unit           val find : 'a t -> key -> 'a           val find_all : 'a t -> key -> 'a list           val replace : 'a t -> key -> '-> unit           val mem : 'a t -> key -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val 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 iter_sorted :             ?cmp:(key -> key -> int) -> (key -> '-> unit) -> 'a t -> unit           val fold_sorted :             ?cmp:(key -> key -> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val iter_sorted_by_entry :             cmp:(key * '-> key * '-> int) ->             (key -> '-> unit) -> 'a t -> unit           val fold_sorted_by_entry :             cmp:(key * '-> key * '-> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val iter_sorted_by_value :             cmp:('-> '-> int) -> (key -> '-> unit) -> 'a t -> unit           val fold_sorted_by_value :             cmp:('-> '-> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val structural_descr : Structural_descr.t -> Structural_descr.t           val make_type : 'Type.t -> 'a t Type.t           val memo : 'a t -> key -> (key -> 'a) -> 'a           module Key :             sig               type t = key               val ty : t Type.t               val name : string               val descr : t Descr.t               val packed_descr : Structural_descr.pack               val reprs : t list               val equal : t -> t -> bool               val compare : t -> t -> int               val hash : t -> int               val pretty_code : Format.formatter -> t -> unit               val internal_pretty_code :                 Type.precedence -> Format.formatter -> t -> unit               val pretty : Format.formatter -> t -> unit               val varname : t -> string               val mem_project : (Project_skeleton.t -> bool) -> t -> bool               val copy : t -> t             end           module Make :             functor (Data : Datatype.S->               sig                 type t = Data.t t                 val ty : t Type.t                 val name : string                 val descr : t Descr.t                 val packed_descr : Structural_descr.pack                 val reprs : t list                 val equal : t -> t -> bool                 val compare : t -> t -> int                 val hash : t -> int                 val pretty_code : Format.formatter -> t -> unit                 val internal_pretty_code :                   Type.precedence -> Format.formatter -> t -> unit                 val pretty : Format.formatter -> t -> unit                 val varname : t -> string                 val mem_project : (Project_skeleton.t -> bool) -> t -> bool                 val copy : t -> t               end         end       val singleton_zero : Locations.Location_Bytes.t       val singleton_one : Locations.Location_Bytes.t       val zero_or_one : Locations.Location_Bytes.t       val is_zero : Locations.Location_Bytes.t -> bool       val is_bottom : Locations.Location_Bytes.t -> bool       val top_int : Locations.Location_Bytes.t       val top_float : Locations.Location_Bytes.t       val top_single_precision_float : Locations.Location_Bytes.t       val inject : Base.t -> Ival.t -> Locations.Location_Bytes.t       val inject_ival : Ival.t -> Locations.Location_Bytes.t       val inject_float : Fval.F.t -> Locations.Location_Bytes.t       val add :         Base.t ->         Ival.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val diff :         Locations.Location_Bytes.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val diff_if_one :         Locations.Location_Bytes.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val shift :         Ival.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val shift_under :         Ival.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val sub_pointwise :         ?factor:Int_Base.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t -> Ival.t       val topify_arith_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_misaligned_read_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_merge_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_leaf_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_with_origin :         Origin.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_with_origin_kind :         Origin.kind ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val inject_top_origin :         Origin.t -> Base.Hptset.t -> Locations.Location_Bytes.t       val top_with_origin : Origin.t -> Locations.Location_Bytes.t       val fold_bases :         (Base.t -> '-> 'a) -> Locations.Location_Bytes.t -> '-> 'a       val fold_i :         (Base.t -> Ival.t -> '-> 'a) ->         Locations.Location_Bytes.t -> '-> 'a       val fold_topset_ok :         (Base.t -> Ival.t -> '-> 'a) ->         Locations.Location_Bytes.t -> '-> 'a       val fold_enum :         (Locations.Location_Bytes.t -> '-> 'a) ->         Locations.Location_Bytes.t -> '-> 'a       val cached_fold :         cache_name:string ->         temporary:bool ->         f:(Base.t -> Ival.t -> 'a) ->         projection:(Base.t -> Ival.t) ->         joiner:('-> '-> 'a) ->         empty:'-> Locations.Location_Bytes.t -> 'a       val filter_base :         (Base.t -> bool) ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val cardinal_zero_or_one : Locations.Location_Bytes.t -> bool       val cardinal_less_than : Locations.Location_Bytes.t -> int -> int       val cardinal : Locations.Location_Bytes.t -> Integer.t option       val find_lonely_key : Locations.Location_Bytes.t -> Base.t * Ival.t       val find_lonely_binding : Locations.Location_Bytes.t -> Base.t * Ival.t       val find : Base.t -> Locations.Location_Bytes.t -> Ival.t       val find_or_bottom : Base.t -> Locations.Location_Bytes.M.t -> Ival.t       val split :         Base.t ->         Locations.Location_Bytes.t -> Ival.t * Locations.Location_Bytes.t       val get_bases : Locations.Location_Bytes.t -> Base.SetLattice.t       val contains_addresses_of_locals :         (Locations.Location_Bytes.M.key -> bool) ->         Locations.Location_Bytes.t -> bool       val remove_escaping_locals :         (Locations.Location_Bytes.M.key -> bool) ->         Locations.Location_Bytes.t ->         Base.SetLattice.t * Locations.Location_Bytes.t       val contains_addresses_of_any_locals :         Locations.Location_Bytes.t -> bool       val iter_on_strings :         skip:Base.t option ->         (Base.t -> string -> int -> int -> unit) ->         Locations.Location_Bytes.t -> unit       val partially_overlaps :         size:Abstract_interp.Int.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t -> bool       val is_relationable : Locations.Location_Bytes.t -> bool       val may_reach : Base.t -> Locations.Location_Bytes.t -> bool       val get_garbled_mix : unit -> Locations.Location_Bytes.t list       val clear_garbled_mix : unit -> unit       val do_track_garbled_mix : bool -> unit       val pretty_debug : Locations.Location_Bytes.t Pretty_utils.formatter       val clear_caches : unit -> unit     end   module Location_Bits :     sig       module M :         sig           type key = Base.t           type t           val iter :             (Base.t -> Ival.t -> unit) ->             Locations.Location_Bytes.M.t -> unit           val find :             Locations.Location_Bytes.M.key ->             Locations.Location_Bytes.M.t -> Ival.t           val fold :             (Base.t -> Ival.t -> '-> 'a) ->             Locations.Location_Bytes.M.t -> '-> 'a           val shape :             Locations.Location_Bytes.M.t -> Ival.t Hptmap.Shape(Base.Base).t         end       type t =           Top of Base.SetLattice.t * Origin.t         | Map of Locations.Location_Bytes.M.t       type size_widen_hint = Ival.size_widen_hint       type generic_widen_hint = Base.t -> Ival.generic_widen_hint       type widen_hint =           Locations.Location_Bytes.size_widen_hint *           Locations.Location_Bytes.generic_widen_hint       val join : t -> t -> t       val is_included : t -> t -> bool       val join_and_is_included : t -> t -> t * bool       val bottom : t       val top : t       val widen : widen_hint -> t -> t -> t       val narrow : t -> t -> t       val link : t -> t -> t       val meet : t -> t -> t       val intersects : t -> t -> bool       exception Error_Top       val ty : t Type.t       val name : string       val descr : t Descr.t       val packed_descr : Structural_descr.pack       val reprs : t list       val equal : t -> t -> bool       val compare : t -> t -> int       val hash : t -> int       val pretty_code : Format.formatter -> t -> unit       val internal_pretty_code :         Type.precedence -> Format.formatter -> t -> unit       val pretty : Format.formatter -> t -> unit       val varname : t -> string       val mem_project : (Project_skeleton.t -> bool) -> t -> bool       val copy : t -> t       module Set :         sig           type elt = t           type t           val empty : t           val is_empty : t -> bool           val mem : elt -> t -> bool           val add : elt -> t -> t           val singleton : elt -> t           val remove : elt -> t -> t           val union : t -> t -> t           val inter : t -> t -> t           val diff : t -> t -> t           val subset : t -> t -> bool           val iter : (elt -> unit) -> t -> unit           val fold : (elt -> '-> 'a) -> t -> '-> 'a           val for_all : (elt -> bool) -> t -> bool           val exists : (elt -> bool) -> t -> bool           val filter : (elt -> bool) -> t -> t           val partition : (elt -> bool) -> t -> t * t           val cardinal : t -> int           val elements : t -> elt list           val choose : t -> elt           val split : elt -> t -> t * bool * t           val find : elt -> t -> elt           val of_list : elt list -> t           val min_elt : t -> elt           val max_elt : t -> elt           val nearest_elt_le : elt -> t -> elt           val nearest_elt_ge : elt -> t -> elt           val ty : t Type.t           val name : string           val descr : t Descr.t           val packed_descr : Structural_descr.pack           val reprs : t list           val equal : t -> t -> bool           val compare : t -> t -> int           val hash : t -> int           val pretty_code : Format.formatter -> t -> unit           val internal_pretty_code :             Type.precedence -> Format.formatter -> t -> unit           val pretty : Format.formatter -> t -> unit           val varname : t -> string           val mem_project : (Project_skeleton.t -> bool) -> t -> bool           val copy : t -> t         end       module Map :         sig           type key = t           type +'a t           val empty : 'a t           val is_empty : 'a t -> bool           val mem : key -> 'a t -> bool           val add : key -> '-> 'a t -> 'a t           val singleton : key -> '-> 'a t           val remove : key -> 'a t -> 'a t           val merge :             (key -> 'a option -> 'b option -> 'c option) ->             'a t -> 'b t -> 'c t           val compare : ('-> '-> int) -> 'a t -> 'a t -> int           val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val for_all : (key -> '-> bool) -> 'a t -> bool           val exists : (key -> '-> bool) -> 'a t -> bool           val filter : (key -> '-> bool) -> 'a t -> 'a t           val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t           val cardinal : 'a t -> int           val bindings : 'a t -> (key * 'a) list           val min_binding : 'a t -> key * 'a           val max_binding : 'a t -> key * 'a           val choose : 'a t -> key * 'a           val split : key -> 'a t -> 'a t * 'a option * 'a t           val find : key -> 'a t -> 'a           val map : ('-> 'b) -> 'a t -> 'b t           val mapi : (key -> '-> 'b) -> 'a t -> 'b t           module Key :             sig               type t = key               val ty : t Type.t               val name : string               val descr : t Descr.t               val packed_descr : Structural_descr.pack               val reprs : t list               val equal : t -> t -> bool               val compare : t -> t -> int               val hash : t -> int               val pretty_code : Format.formatter -> t -> unit               val internal_pretty_code :                 Type.precedence -> Format.formatter -> t -> unit               val pretty : Format.formatter -> t -> unit               val varname : t -> string               val mem_project : (Project_skeleton.t -> bool) -> t -> bool               val copy : t -> t             end           module Make :             functor (Data : Datatype.S->               sig                 type t = Data.t t                 val ty : t Type.t                 val name : string                 val descr : t Descr.t                 val packed_descr : Structural_descr.pack                 val reprs : t list                 val equal : t -> t -> bool                 val compare : t -> t -> int                 val hash : t -> int                 val pretty_code : Format.formatter -> t -> unit                 val internal_pretty_code :                   Type.precedence -> Format.formatter -> t -> unit                 val pretty : Format.formatter -> t -> unit                 val varname : t -> string                 val mem_project : (Project_skeleton.t -> bool) -> t -> bool                 val copy : t -> t               end         end       module Hashtbl :         sig           type key = t           type 'a t           val create : int -> 'a t           val clear : 'a t -> unit           val reset : 'a t -> unit           val copy : 'a t -> 'a t           val add : 'a t -> key -> '-> unit           val remove : 'a t -> key -> unit           val find : 'a t -> key -> 'a           val find_all : 'a t -> key -> 'a list           val replace : 'a t -> key -> '-> unit           val mem : 'a t -> key -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val 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 iter_sorted :             ?cmp:(key -> key -> int) -> (key -> '-> unit) -> 'a t -> unit           val fold_sorted :             ?cmp:(key -> key -> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val iter_sorted_by_entry :             cmp:(key * '-> key * '-> int) ->             (key -> '-> unit) -> 'a t -> unit           val fold_sorted_by_entry :             cmp:(key * '-> key * '-> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val iter_sorted_by_value :             cmp:('-> '-> int) -> (key -> '-> unit) -> 'a t -> unit           val fold_sorted_by_value :             cmp:('-> '-> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val structural_descr : Structural_descr.t -> Structural_descr.t           val make_type : 'Type.t -> 'a t Type.t           val memo : 'a t -> key -> (key -> 'a) -> 'a           module Key :             sig               type t = key               val ty : t Type.t               val name : string               val descr : t Descr.t               val packed_descr : Structural_descr.pack               val reprs : t list               val equal : t -> t -> bool               val compare : t -> t -> int               val hash : t -> int               val pretty_code : Format.formatter -> t -> unit               val internal_pretty_code :                 Type.precedence -> Format.formatter -> t -> unit               val pretty : Format.formatter -> t -> unit               val varname : t -> string               val mem_project : (Project_skeleton.t -> bool) -> t -> bool               val copy : t -> t             end           module Make :             functor (Data : Datatype.S->               sig                 type t = Data.t t                 val ty : t Type.t                 val name : string                 val descr : t Descr.t                 val packed_descr : Structural_descr.pack                 val reprs : t list                 val equal : t -> t -> bool                 val compare : t -> t -> int                 val hash : t -> int                 val pretty_code : Format.formatter -> t -> unit                 val internal_pretty_code :                   Type.precedence -> Format.formatter -> t -> unit                 val pretty : Format.formatter -> t -> unit                 val varname : t -> string                 val mem_project : (Project_skeleton.t -> bool) -> t -> bool                 val copy : t -> t               end         end       val singleton_zero : Locations.Location_Bytes.t       val singleton_one : Locations.Location_Bytes.t       val zero_or_one : Locations.Location_Bytes.t       val is_zero : Locations.Location_Bytes.t -> bool       val is_bottom : Locations.Location_Bytes.t -> bool       val top_int : Locations.Location_Bytes.t       val top_float : Locations.Location_Bytes.t       val top_single_precision_float : Locations.Location_Bytes.t       val inject : Base.t -> Ival.t -> Locations.Location_Bytes.t       val inject_ival : Ival.t -> Locations.Location_Bytes.t       val inject_float : Fval.F.t -> Locations.Location_Bytes.t       val add :         Base.t ->         Ival.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val diff :         Locations.Location_Bytes.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val diff_if_one :         Locations.Location_Bytes.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val shift :         Ival.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val shift_under :         Ival.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val sub_pointwise :         ?factor:Int_Base.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t -> Ival.t       val topify_arith_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_misaligned_read_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_merge_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_leaf_origin :         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_with_origin :         Origin.t -> Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val topify_with_origin_kind :         Origin.kind ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val inject_top_origin :         Origin.t -> Base.Hptset.t -> Locations.Location_Bytes.t       val top_with_origin : Origin.t -> Locations.Location_Bytes.t       val fold_bases :         (Base.t -> '-> 'a) -> Locations.Location_Bytes.t -> '-> 'a       val fold_i :         (Base.t -> Ival.t -> '-> 'a) ->         Locations.Location_Bytes.t -> '-> 'a       val fold_topset_ok :         (Base.t -> Ival.t -> '-> 'a) ->         Locations.Location_Bytes.t -> '-> 'a       val fold_enum :         (Locations.Location_Bytes.t -> '-> 'a) ->         Locations.Location_Bytes.t -> '-> 'a       val cached_fold :         cache_name:string ->         temporary:bool ->         f:(Base.t -> Ival.t -> 'a) ->         projection:(Base.t -> Ival.t) ->         joiner:('-> '-> 'a) ->         empty:'-> Locations.Location_Bytes.t -> 'a       val filter_base :         (Base.t -> bool) ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t       val cardinal_zero_or_one : Locations.Location_Bytes.t -> bool       val cardinal_less_than : Locations.Location_Bytes.t -> int -> int       val cardinal : Locations.Location_Bytes.t -> Integer.t option       val find_lonely_key : Locations.Location_Bytes.t -> Base.t * Ival.t       val find_lonely_binding : Locations.Location_Bytes.t -> Base.t * Ival.t       val find : Base.t -> Locations.Location_Bytes.t -> Ival.t       val find_or_bottom : Base.t -> Locations.Location_Bytes.M.t -> Ival.t       val split :         Base.t ->         Locations.Location_Bytes.t -> Ival.t * Locations.Location_Bytes.t       val get_bases : Locations.Location_Bytes.t -> Base.SetLattice.t       val contains_addresses_of_locals :         (Locations.Location_Bytes.M.key -> bool) ->         Locations.Location_Bytes.t -> bool       val remove_escaping_locals :         (Locations.Location_Bytes.M.key -> bool) ->         Locations.Location_Bytes.t ->         Base.SetLattice.t * Locations.Location_Bytes.t       val contains_addresses_of_any_locals :         Locations.Location_Bytes.t -> bool       val iter_on_strings :         skip:Base.t option ->         (Base.t -> string -> int -> int -> unit) ->         Locations.Location_Bytes.t -> unit       val partially_overlaps :         size:Abstract_interp.Int.t ->         Locations.Location_Bytes.t -> Locations.Location_Bytes.t -> bool       val is_relationable : Locations.Location_Bytes.t -> bool       val may_reach : Base.t -> Locations.Location_Bytes.t -> bool       val get_garbled_mix : unit -> Locations.Location_Bytes.t list       val clear_garbled_mix : unit -> unit       val do_track_garbled_mix : bool -> unit       val pretty_debug : Locations.Location_Bytes.t Pretty_utils.formatter       val clear_caches : unit -> unit     end   module Zone :     sig       type map_t       type t = private           Top of Base.SetLattice.t * Origin.t         | Map of Locations.Zone.map_t       module Set :         sig           type elt = t           type t           val empty : t           val is_empty : t -> bool           val mem : elt -> t -> bool           val add : elt -> t -> t           val singleton : elt -> t           val remove : elt -> t -> t           val union : t -> t -> t           val inter : t -> t -> t           val diff : t -> t -> t           val subset : t -> t -> bool           val iter : (elt -> unit) -> t -> unit           val fold : (elt -> '-> 'a) -> t -> '-> 'a           val for_all : (elt -> bool) -> t -> bool           val exists : (elt -> bool) -> t -> bool           val filter : (elt -> bool) -> t -> t           val partition : (elt -> bool) -> t -> t * t           val cardinal : t -> int           val elements : t -> elt list           val choose : t -> elt           val split : elt -> t -> t * bool * t           val find : elt -> t -> elt           val of_list : elt list -> t           val min_elt : t -> elt           val max_elt : t -> elt           val nearest_elt_le : elt -> t -> elt           val nearest_elt_ge : elt -> t -> elt           val ty : t Type.t           val name : string           val descr : t Descr.t           val packed_descr : Structural_descr.pack           val reprs : t list           val equal : t -> t -> bool           val compare : t -> t -> int           val hash : t -> int           val pretty_code : Format.formatter -> t -> unit           val internal_pretty_code :             Type.precedence -> Format.formatter -> t -> unit           val pretty : Format.formatter -> t -> unit           val varname : t -> string           val mem_project : (Project_skeleton.t -> bool) -> t -> bool           val copy : t -> t         end       module Map :         sig           type key = t           type +'a t           val empty : 'a t           val is_empty : 'a t -> bool           val mem : key -> 'a t -> bool           val add : key -> '-> 'a t -> 'a t           val singleton : key -> '-> 'a t           val remove : key -> 'a t -> 'a t           val merge :             (key -> 'a option -> 'b option -> 'c option) ->             'a t -> 'b t -> 'c t           val compare : ('-> '-> int) -> 'a t -> 'a t -> int           val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val for_all : (key -> '-> bool) -> 'a t -> bool           val exists : (key -> '-> bool) -> 'a t -> bool           val filter : (key -> '-> bool) -> 'a t -> 'a t           val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t           val cardinal : 'a t -> int           val bindings : 'a t -> (key * 'a) list           val min_binding : 'a t -> key * 'a           val max_binding : 'a t -> key * 'a           val choose : 'a t -> key * 'a           val split : key -> 'a t -> 'a t * 'a option * 'a t           val find : key -> 'a t -> 'a           val map : ('-> 'b) -> 'a t -> 'b t           val mapi : (key -> '-> 'b) -> 'a t -> 'b t           module Key :             sig               type t = key               val ty : t Type.t               val name : string               val descr : t Descr.t               val packed_descr : Structural_descr.pack               val reprs : t list               val equal : t -> t -> bool               val compare : t -> t -> int               val hash : t -> int               val pretty_code : Format.formatter -> t -> unit               val internal_pretty_code :                 Type.precedence -> Format.formatter -> t -> unit               val pretty : Format.formatter -> t -> unit               val varname : t -> string               val mem_project : (Project_skeleton.t -> bool) -> t -> bool               val copy : t -> t             end           module Make :             functor (Data : Datatype.S->               sig                 type t = Data.t t                 val ty : t Type.t                 val name : string                 val descr : t Descr.t                 val packed_descr : Structural_descr.pack                 val reprs : t list                 val equal : t -> t -> bool                 val compare : t -> t -> int                 val hash : t -> int                 val pretty_code : Format.formatter -> t -> unit                 val internal_pretty_code :                   Type.precedence -> Format.formatter -> t -> unit                 val pretty : Format.formatter -> t -> unit                 val varname : t -> string                 val mem_project : (Project_skeleton.t -> bool) -> t -> bool                 val copy : t -> t               end         end       module Hashtbl :         sig           type key = t           type 'a t           val create : int -> 'a t           val clear : 'a t -> unit           val reset : 'a t -> unit           val copy : 'a t -> 'a t           val add : 'a t -> key -> '-> unit           val remove : 'a t -> key -> unit           val find : 'a t -> key -> 'a           val find_all : 'a t -> key -> 'a list           val replace : 'a t -> key -> '-> unit           val mem : 'a t -> key -> bool           val iter : (key -> '-> unit) -> 'a t -> unit           val 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 iter_sorted :             ?cmp:(key -> key -> int) -> (key -> '-> unit) -> 'a t -> unit           val fold_sorted :             ?cmp:(key -> key -> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val iter_sorted_by_entry :             cmp:(key * '-> key * '-> int) ->             (key -> '-> unit) -> 'a t -> unit           val fold_sorted_by_entry :             cmp:(key * '-> key * '-> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val iter_sorted_by_value :             cmp:('-> '-> int) -> (key -> '-> unit) -> 'a t -> unit           val fold_sorted_by_value :             cmp:('-> '-> int) ->             (key -> '-> '-> 'b) -> 'a t -> '-> 'b           val structural_descr : Structural_descr.t -> Structural_descr.t           val make_type : 'Type.t -> 'a t Type.t           val memo : 'a t -> key -> (key -> 'a) -> 'a           module Key :             sig               type t = key               val ty : t Type.t               val name : string               val descr : t Descr.t               val packed_descr : Structural_descr.pack               val reprs : t list               val equal : t -> t -> bool               val compare : t -> t -> int               val hash : t -> int               val pretty_code : Format.formatter -> t -> unit               val internal_pretty_code :                 Type.precedence -> Format.formatter -> t -> unit               val pretty : Format.formatter -> t -> unit               val varname : t -> string               val mem_project : (Project_skeleton.t -> bool) -> t -> bool               val copy : t -> t             end           module Make :             functor (Data : Datatype.S->               sig                 type t = Data.t t                 val ty : t Type.t                 val name : string                 val descr : t Descr.t                 val packed_descr : Structural_descr.pack                 val reprs : t list                 val equal : t -> t -> bool                 val compare : t -> t -> int                 val hash : t -> int                 val pretty_code : Format.formatter -> t -> unit                 val internal_pretty_code :                   Type.precedence -> Format.formatter -> t -> unit                 val pretty : Format.formatter -> t -> unit                 val varname : t -> string                 val mem_project : (Project_skeleton.t -> bool) -> t -> bool                 val copy : t -> t               end         end       val pretty_debug : Locations.Zone.t Pretty_utils.formatter       val ty : t Type.t       val name : string       val descr : t Descr.t       val packed_descr : Structural_descr.pack       val reprs : t list       val equal : t -> t -> bool       val compare : t -> t -> int       val hash : t -> int       val pretty_code : Format.formatter -> t -> unit       val internal_pretty_code :         Type.precedence -> Format.formatter -> t -> unit       val pretty : Format.formatter -> t -> unit       val varname : t -> string       val mem_project : (Project_skeleton.t -> bool) -> t -> bool       val copy : t -> t       val join : t -> t -> t       val is_included : t -> t -> bool       val join_and_is_included : t -> t -> t * bool       val bottom : t       val top : t       val narrow : t -> t -> t       val link : t -> t -> t       val meet : t -> t -> t       val diff : t -> t -> t       val is_bottom : Locations.Zone.t -> bool       val inject : Base.t -> Int_Intervals.t -> Locations.Zone.t       exception Error_Top       val map_i :         (Base.t -> Int_Intervals.t -> Locations.Zone.t) ->         Locations.Zone.t -> Locations.Zone.t       val find_lonely_key : Locations.Zone.t -> Base.t * Int_Intervals.t       val find_or_bottom : Base.t -> Locations.Zone.map_t -> Int_Intervals.t       val find : Base.t -> Locations.Zone.t -> Int_Intervals.t       val mem_base : Base.t -> Locations.Zone.t -> bool       val intersects : Locations.Zone.t -> Locations.Zone.t -> bool       val valid_intersects : Locations.Zone.t -> Locations.Zone.t -> bool       val filter_base :         (Base.t -> bool) -> Locations.Zone.t -> Locations.Zone.t       val fold_bases : (Base.t -> '-> 'a) -> Locations.Zone.t -> '-> 'a       val fold_i :         (Base.t -> Int_Intervals.t -> '-> 'a) ->         Locations.Zone.t -> '-> 'a       val fold_topset_ok :         (Base.t -> Int_Intervals.t -> '-> 'a) ->         Locations.Zone.t -> '-> 'a       val cached_fold :         cache_name:string ->         temporary:bool ->         f:(Base.t -> Int_Intervals.t -> 'b) ->         projection:(Base.t -> Int_Intervals.t) ->         joiner:('-> '-> 'b) -> empty:'-> Locations.Zone.t -> 'b       val fold2_join_heterogeneous :         cache:Hptmap_sig.cache_type ->         empty_left:('Hptmap.Shape(Base.Base).t -> 'b) ->         empty_right:(Locations.Zone.t -> 'b) ->         both:(Base.t -> Int_Intervals.t -> '-> 'b) ->         join:('-> '-> 'b) ->         empty:'-> Locations.Zone.t -> 'Hptmap.Shape(Base.Base).t -> 'b       val shape :         Locations.Zone.map_t -> Int_Intervals.t Hptmap.Shape(Base.Base).t       val clear_caches : unit -> unit     end   type location = private {     loc : Locations.Location_Bits.t;     size : Int_Base.t;   }   module Location :     sig       type t = location       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 loc_bottom : Locations.location   val is_bottom_loc : Locations.location -> bool   val make_loc :     Locations.Location_Bits.t -> Int_Base.t -> Locations.location   val loc_equal : Locations.location -> Locations.location -> bool   val loc_size : Locations.location -> Int_Base.t   val is_valid : for_writing:bool -> Locations.location -> bool   val valid_part :     for_writing:bool ->     ?bitfield:bool -> Locations.location -> Locations.location   val invalid_part : Locations.location -> Locations.location   val cardinal_zero_or_one : Locations.location -> bool   val valid_cardinal_zero_or_one :     for_writing:bool -> Locations.location -> bool   val filter_base :     (Base.t -> bool) -> Locations.location -> Locations.location   val filter_loc :     Locations.location -> Locations.Zone.t -> Locations.location   val pretty : Format.formatter -> Locations.location -> unit   val pretty_english :     prefix:bool -> Format.formatter -> Locations.location -> unit   val loc_to_loc_without_size :     Locations.location -> Locations.Location_Bytes.t   val loc_bytes_to_loc_bits :     Locations.Location_Bytes.t -> Locations.Location_Bits.t   val loc_bits_to_loc_bytes :     Locations.Location_Bits.t -> Locations.Location_Bytes.t   val loc_bits_to_loc_bytes_under :     Locations.Location_Bits.t -> Locations.Location_Bytes.t   val enumerate_bits : Locations.location -> Locations.Zone.t   val enumerate_bits_under : Locations.location -> Locations.Zone.t   val enumerate_valid_bits :     for_writing:bool -> Locations.location -> Locations.Zone.t   val enumerate_valid_bits_under :     for_writing:bool -> Locations.location -> Locations.Zone.t   val zone_of_varinfo : Cil_types.varinfo -> Locations.Zone.t   val loc_of_varinfo : Cil_types.varinfo -> Locations.location   val loc_of_base : Base.t -> Locations.location   val loc_of_typoffset :     Base.t -> Cil_types.typ -> Cil_types.offset -> Locations.location end