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
        end
      module Top_Param :
        sig
          module O :
            sig
              type elt = Base.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 equal : t -> t -> bool
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val cardinal : t -> int
            end
          type tt = private Set of O.t | Top
          exception Error_Top
          exception Error_Bottom
          type t = tt
          type widen_hint = O.t
          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 hash : t -> int
          val inject_singleton : O.elt -> t
          val inject : O.t -> t
          val empty : t
          val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
          val apply1 : (O.elt -> O.elt) -> t -> t
          val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
          val iter : (O.elt -> unit) -> t -> unit
          val project : t -> O.t
          val mem : O.elt -> t -> bool
        end
      type z =
          Top of Locations.Location_Bytes.Top_Param.t * Origin.t
        | Map of Locations.Location_Bytes.M.t
      exception Error_Top
      exception Error_Bottom
      type t = z
      type widen_hint = Top_Param.widen_hint * (Base.t -> Ival.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 top_float : t
      val is_zero : t -> bool
      val hash : t -> int
      val zero_or_one : t
      val singleton_zero : t
      val singleton_one : t
      val topify_arith_origin : t -> t
      val topify_misaligned_read_origin : t -> t
      val topify_merge_origin : t -> t
      val under_topify : t -> t
      val top_int : t
      val find_or_bottom : Base.t -> Locations.Location_Bytes.M.t -> Ival.t
      val add_or_bottom :
        Base.t ->
        Ival.t ->
        Locations.Location_Bytes.M.t -> Locations.Location_Bytes.M.t
      val inject : Base.t -> Ival.t -> t
      val inject_ival : Ival.t -> t
      val inject_top_origin :
        Origin.t -> Locations.Location_Bytes.Top_Param.O.t -> t
      val fold_enum :
        split_non_enumerable:int -> (t -> '-> 'a) -> t -> '-> 'a
      val splitting_cardinal_less_than :
        split_non_enumerable:int -> t -> int -> int
      val find_exclusive : Base.t -> t -> Ival.t
      val split : Base.t -> t -> Ival.t * t
      exception Not_all_keys
      val get_keys_exclusive : Ival.t -> t -> Base.t list
      val find_lonely_binding : t -> Base.t * Ival.t
      val find_lonely_key : t -> Base.t * Ival.t
      val diff : t -> t -> t
      val diff_if_one : t -> t -> t
      val location_shift : Ival.t -> t -> t
      val fold_i : (Base.t -> Ival.t -> '-> 'a) -> t -> '-> 'a
      val fold_bases : (Base.t -> '-> 'a) -> t -> '-> 'a
      val top_leaf_origin : unit -> t
      val topify_with_origin : Origin.t -> t -> t
      val is_included_actual_generic :
        BaseUtils.BaseSet.t ->
        BaseUtils.BaseSet.t Pervasives.ref ->
        t BaseUtils.BaseMap.t Pervasives.ref -> t -> t -> unit
      val may_reach : Base.t -> t -> bool
      val cached_fold :
        cache:string * int ->
        f:(Base.t -> Ival.t -> 'a) ->
        projection:(Base.t -> Ival.t) ->
        joiner:('-> '-> 'a) -> empty:'-> t -> 'a
      val contains_addresses_of_locals :
        (Locations.Location_Bytes.M.key -> bool) -> t -> bool
      val remove_escaping_locals :
        (Locations.Location_Bytes.M.key -> bool) -> t -> t
      val contains_addresses_of_any_locals : t -> bool
    end
  module Location_Bits :
    sig
      module M :
        sig
          type key = Base.t
          type t
          val find :
            Locations.Location_Bits.M.key ->
            Locations.Location_Bits.M.t -> Ival.t
          val fold :
            (Base.t -> Ival.t -> '-> 'a) ->
            Locations.Location_Bits.M.t -> '-> 'a
        end
      module Top_Param :
        sig
          module O :
            sig
              type elt = Base.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 equal : t -> t -> bool
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val cardinal : t -> int
            end
          type tt = private Set of O.t | Top
          exception Error_Top
          exception Error_Bottom
          type t = tt
          type widen_hint = O.t
          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 hash : t -> int
          val inject_singleton : O.elt -> t
          val inject : O.t -> t
          val empty : t
          val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
          val apply1 : (O.elt -> O.elt) -> t -> t
          val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
          val iter : (O.elt -> unit) -> t -> unit
          val project : t -> O.t
          val mem : O.elt -> t -> bool
        end
      type t =
          Top of Locations.Location_Bits.Top_Param.t * Origin.t
        | Map of Locations.Location_Bits.M.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
      val top : Locations.Location_Bits.t
      val bottom : Locations.Location_Bits.t
      val find_or_bottom : Base.t -> Locations.Location_Bits.M.t -> Ival.t
      val add_or_bottom :
        Base.t ->
        Ival.t -> Locations.Location_Bits.M.t -> Locations.Location_Bits.M.t
      val inject : Base.t -> Ival.t -> Locations.Location_Bits.t
      val inject_ival : Ival.t -> Locations.Location_Bits.t
      val join :
        Locations.Location_Bits.t ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      val link :
        Locations.Location_Bits.t ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      val narrow :
        Locations.Location_Bits.t ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      val meet :
        Locations.Location_Bits.t ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      val diff :
        Locations.Location_Bits.t ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      val diff_if_one :
        Locations.Location_Bits.t ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      exception Error_Bottom
      exception Error_Top
      val find_exclusive : Base.t -> Locations.Location_Bits.t -> Ival.t
      exception Not_all_keys
      val get_keys_exclusive :
        Ival.t -> Locations.Location_Bits.t -> Base.t list
      val pretty : Format.formatter -> Locations.Location_Bits.t -> unit
      val intersects :
        Locations.Location_Bits.t -> Locations.Location_Bits.t -> bool
      val inject_top_origin :
        Origin.t ->
        Locations.Location_Bits.Top_Param.O.t -> Locations.Location_Bits.t
      val topify_arith_origin :
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      type widen_hint
      val widen :
        Locations.Location_Bits.widen_hint ->
        Locations.Location_Bits.t ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      val equal :
        Locations.Location_Bits.t -> Locations.Location_Bits.t -> bool
      val hash : Locations.Location_Bits.t -> int
      val is_included :
        Locations.Location_Bits.t -> Locations.Location_Bits.t -> bool
      val find_lonely_binding : Locations.Location_Bits.t -> Base.t * Ival.t
      val find_lonely_key : Locations.Location_Bits.t -> Base.t * Ival.t
      val cardinal_zero_or_one : Locations.Location_Bits.t -> bool
      val cardinal_less_than : Locations.Location_Bits.t -> int -> int
      val location_shift :
        Ival.t -> Locations.Location_Bits.t -> Locations.Location_Bits.t
      val filter_base :
        (Base.t -> bool) ->
        Locations.Location_Bits.t -> Locations.Location_Bits.t
      val fold_i :
        (Base.t -> Ival.t -> '-> 'a) ->
        Locations.Location_Bits.t -> '-> 'a
      val fold_enum :
        split_non_enumerable:int ->
        (Locations.Location_Bits.t -> '-> 'a) ->
        Locations.Location_Bits.t -> '-> 'a
      val is_in_set :
        set:Locations.Location_Bits.Top_Param.O.t -> Base.t -> bool
      val fold_bases :
        (Base.t -> '-> 'a) -> Locations.Location_Bits.t -> '-> 'a
      val get_bases :
        Locations.Location_Bits.t -> Locations.Location_Bits.Top_Param.t
    end
  module Zone :
    sig
      module Top_Param :
        sig
          module O :
            sig
              type elt = Base.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 equal : t -> t -> bool
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val cardinal : t -> int
            end
          type tt = private Set of O.t | Top
          exception Error_Top
          exception Error_Bottom
          type t = tt
          type widen_hint = O.t
          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 hash : t -> int
          val inject_singleton : O.elt -> t
          val inject : O.t -> t
          val empty : t
          val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
          val apply1 : (O.elt -> O.elt) -> t -> t
          val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
          val iter : (O.elt -> unit) -> t -> unit
          val project : t -> O.t
          val mem : O.elt -> t -> bool
        end
      type map_t
      type t =
          Top of Locations.Zone.Top_Param.t * Origin.t
        | Map of Locations.Zone.map_t
      val top : Locations.Zone.t
      val bottom : Locations.Zone.t
      val id : string
      val tag : Locations.Zone.t -> int
      val inject :
        Base.t -> Abstract_value.Int_Intervals.t -> Locations.Zone.t
      val join : Locations.Zone.t -> Locations.Zone.t -> Locations.Zone.t
      val link : Locations.Zone.t -> Locations.Zone.t -> Locations.Zone.t
      val narrow : Locations.Zone.t -> Locations.Zone.t -> Locations.Zone.t
      val meet : Locations.Zone.t -> Locations.Zone.t -> Locations.Zone.t
      val diff : t -> t -> t
      val diff_if_one :
        Locations.Zone.t -> Locations.Zone.t -> Locations.Zone.t
      exception Error_Bottom
      exception Error_Top
      val map_i :
        (Base.t -> Abstract_value.Int_Intervals.t -> Locations.Zone.t) ->
        Locations.Zone.t -> Locations.Zone.t
      val find_exclusive :
        Base.t -> Locations.Zone.t -> Abstract_value.Int_Intervals.t
      val find_lonely_key :
        Locations.Zone.t -> Base.t * Abstract_value.Int_Intervals.t
      val find_or_bottom :
        Base.t -> Locations.Zone.map_t -> Abstract_value.Int_Intervals.t
      exception Not_all_keys
      val get_keys_exclusive :
        Abstract_value.Int_Intervals.t -> Locations.Zone.t -> Base.t list
      val pretty : Format.formatter -> Locations.Zone.t -> unit
      val intersects : Locations.Zone.t -> Locations.Zone.t -> bool
      val valid_intersects : Locations.Zone.t -> Locations.Zone.t -> bool
      type widen_hint
      val widen :
        Locations.Zone.widen_hint ->
        Locations.Zone.t -> Locations.Zone.t -> Locations.Zone.t
      val equal : Locations.Zone.t -> Locations.Zone.t -> bool
      val is_included : Locations.Zone.t -> Locations.Zone.t -> bool
      val is_included_exn : Locations.Zone.t -> Locations.Zone.t -> unit
      val cardinal_zero_or_one : Locations.Zone.t -> bool
      val cardinal_less_than : Locations.Zone.t -> int -> int
      val diff : Locations.Zone.t -> Locations.Zone.t -> Locations.Zone.t
      val filter_base :
        (Base.t -> bool) -> Locations.Zone.t -> Locations.Zone.t
      val fold_bases : (Base.t -> '-> 'a) -> Locations.Zone.t -> '-> 'a
      val get_bases : Locations.Zone.t -> Locations.Zone.Top_Param.t
      val fold_i :
        (Base.t -> Abstract_value.Int_Intervals.t -> '-> 'a) ->
        Locations.Zone.t -> '-> 'a
      val fold_topset_ok :
        (Base.t -> Abstract_value.Int_Intervals.t -> '-> 'a) ->
        Locations.Zone.t -> '-> 'a
      val fold_enum_by_base :
        (Locations.Zone.t -> '-> 'a) -> Locations.Zone.t -> '-> 'a
      val out_some_or_bottom : Locations.Zone.t option -> Locations.Zone.t
      val cached_fold :
        cache:string * int ->
        f:(Base.t -> Abstract_value.Int_Intervals.t -> 'a) ->
        projection:(Base.t -> Abstract_value.Int_Intervals.t) ->
        joiner:('-> '-> 'a) -> empty:'-> Locations.Zone.t -> 'a
      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 default :
        Base.t ->
        Abstract_interp.Int.t -> Abstract_interp.Int.t -> Locations.Zone.t
      val defaultall : Base.t -> Locations.Zone.t
    end
  type location = private {
    loc : Locations.Location_Bits.t;
    size : Int_Base.t;
  }
  module Location :
    sig
      module Datatype :
        sig
          type t = location
          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 loc_bottom : Locations.location
  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 can_be_accessed : Locations.location -> bool
  val is_valid : Locations.location -> bool
  val cardinal_zero_or_one : Locations.location -> bool
  val valid_cardinal_zero_or_one : Locations.location -> bool
  val valid_part : Locations.location -> Locations.location
  val invalid_part : Locations.location -> Locations.location
  val pretty : 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_without_size_to_loc :
    Cil_types.lval -> Locations.Location_Bytes.t -> Locations.location
  val loc_bits_to_loc :
    Cil_types.lval -> Locations.Location_Bits.t -> Locations.location
  val valid_enumerate_bits : Locations.location -> 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
  val filter_loc :
    Locations.location -> Locations.Zone.t -> Locations.location
end