sig   module Dpd :     sig       type t       type td = Ctrl | Addr | Data       val make : ?a:bool -> ?d:bool -> ?c:bool -> unit -> PdgTypes.Dpd.t       val top : PdgTypes.Dpd.t       val bottom : PdgTypes.Dpd.t       val is_addr : PdgTypes.Dpd.t -> bool       val is_ctrl : PdgTypes.Dpd.t -> bool       val is_data : PdgTypes.Dpd.t -> bool       val adc_value : PdgTypes.Dpd.t -> bool * bool * bool       val is_dpd : PdgTypes.Dpd.td -> PdgTypes.Dpd.t -> bool       val is_bottom : PdgTypes.Dpd.t -> bool       val is_included : PdgTypes.Dpd.t -> PdgTypes.Dpd.t -> bool       val compare : PdgTypes.Dpd.t -> PdgTypes.Dpd.t -> int       val equal : PdgTypes.Dpd.t -> PdgTypes.Dpd.t -> bool       val combine : PdgTypes.Dpd.t -> PdgTypes.Dpd.t -> PdgTypes.Dpd.t       val add : PdgTypes.Dpd.t -> PdgTypes.Dpd.td -> PdgTypes.Dpd.t       val inter : PdgTypes.Dpd.t -> PdgTypes.Dpd.t -> PdgTypes.Dpd.t       val intersect : PdgTypes.Dpd.t -> PdgTypes.Dpd.t -> bool       val minus : PdgTypes.Dpd.t -> PdgTypes.Dpd.t -> PdgTypes.Dpd.t       val pretty_td : Format.formatter -> PdgTypes.Dpd.td -> unit       val pretty : Format.formatter -> PdgTypes.Dpd.t -> unit     end   module Node :     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       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 id : t -> int       val elem_key : t -> PdgIndex.Key.t       val stmt : t -> Cil_types.stmt option       val pretty_list : Format.formatter -> t list -> unit       val pretty_with_part :         Format.formatter -> t * Locations.Zone.t option -> unit       val pretty_node : Format.formatter -> t -> unit     end   module NodeSet :     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 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       type elt = Node.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 compare : t -> t -> int       val equal : t -> t -> bool       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 contains_single_elt : t -> elt option       val intersects : t -> t -> bool       type action = Neutral | Absorbing | Traversing of (elt -> bool)       val merge :         cache:Hptmap_sig.cache_type ->         symmetric:bool ->         idempotent:bool ->         decide_both:(elt -> bool) ->         decide_left:action -> decide_right:action -> t -> t -> t       type 'a shape       val shape : t -> unit shape       val from_shape : 'a shape -> t       val fold2_join_heterogeneous :         cache:Hptmap_sig.cache_type ->         empty_left:('a shape -> 'b) ->         empty_right:(t -> 'b) ->         both:(elt -> '-> 'b) ->         join:('-> '-> 'b) -> empty:'-> t -> 'a shape -> 'b       val clear_caches : unit -> unit       val pretty_debug : t Pretty_utils.formatter     end   module G :     sig       type t       module E :         sig           type t           type label           val src : PdgTypes.G.E.t -> PdgTypes.Node.t           val dst : PdgTypes.G.E.t -> PdgTypes.Node.t           val label : PdgTypes.G.E.t -> PdgTypes.G.E.label         end       val create : unit -> PdgTypes.G.t       val add_elem : PdgTypes.G.t -> PdgIndex.Key.t -> PdgTypes.Node.t       val add_dpd :         PdgTypes.G.t ->         PdgTypes.Node.t ->         PdgTypes.Dpd.td -> Locations.Zone.t option -> PdgTypes.Node.t -> unit     end   module NodeSetLattice :     sig       module O :         sig           type elt = Node.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       exception Error_Top       type t = private Set of O.t | 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       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       type widen_hint = O.t       val widen : widen_hint -> t -> t -> t       val cardinal_zero_or_one : t -> bool       val narrow : t -> t -> t       val link : t -> t -> t       val meet : t -> t -> t       val intersects : t -> t -> bool       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 exists : (O.elt -> bool) -> t -> bool       val for_all : (O.elt -> bool) -> t -> bool       val project : t -> O.t       val mem : O.elt -> t -> bool       val default : t     end   module LocInfo :     sig       type v = NodeSetLattice.t       type map       type lmap = Top | Map of map | Bottom       type t = lmap       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       module LOffset :         sig           type v = v           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 varname : t -> string           val mem_project : (Project_skeleton.t -> bool) -> t -> bool           val copy : t -> t           type intervals = Int_Intervals.t           val pretty : t Pretty_utils.formatter           val pretty_generic :             ?typ:Cil_types.typ ->             ?pretty_v:(Format.formatter -> v -> unit) ->             ?skip_v:(v -> bool) ->             ?sep:string -> unit -> Format.formatter -> t -> unit           val pretty_debug : t Pretty_utils.formatter           val join : t -> t -> t           val is_included : t -> t -> bool           val find : Int_Intervals_sig.itv -> t -> v           val find_iset : validity:Base.validity -> intervals -> t -> v           val add_binding_intervals :             validity:Base.validity ->             exact:bool -> intervals -> v -> t -> t Bottom.or_bottom           val add_binding_ival :             validity:Base.validity ->             exact:bool ->             Ival.t -> size:Int_Base.t -> v -> t -> t Bottom.or_bottom           val create : size:Integer.t -> v -> t           val empty : t           val size_from_validity :             Base.validity -> Integer.t Bottom.or_bottom           val map : (v -> v) -> t -> t           type map2_decide =               ReturnLeft             | ReturnRight             | ReturnConstant of v             | Recurse           val map2 :             Hptmap_sig.cache_type ->             (t -> t -> map2_decide) -> (v -> v -> v) -> t -> t -> t           val fold : (intervals -> v -> '-> 'a) -> t -> '-> 'a           val fold_fuse_same : (intervals -> v -> '-> 'a) -> t -> '-> 'a           val fold_itv :             ?direction:[ `LTR | `RTL ] ->             entire:bool ->             (Int_Intervals_sig.itv -> v -> '-> 'a) ->             Int_Intervals_sig.itv -> t -> '-> 'a           val fold_join_itvs :             cache:Hptmap_sig.cache_type ->             (Integer.t -> Integer.t -> v -> 'a) ->             ('-> '-> 'a) -> '-> intervals -> t -> 'a           val is_single_interval : t -> bool           val single_interval_value : t -> v option           val is_same_value : t -> v -> bool           val clear_caches : unit -> unit           val imprecise_write_msg : string ref         end       val is_empty : t -> bool       val is_bottom : t -> bool       val empty : t       val empty_map : map       val pretty_generic_printer :         ?pretty_v:v Pretty_utils.formatter ->         ?skip_v:(v -> bool) -> sep:string -> unit -> t Pretty_utils.formatter       val pretty_debug : t Pretty_utils.formatter       val add_binding :         reducing:bool -> exact:bool -> t -> Locations.Zone.t -> v -> t       val add_binding_loc :         reducing:bool -> exact:bool -> t -> Locations.location -> v -> t       val add_base : Base.t -> LOffset.t -> t -> t       val remove_base : Base.t -> t -> t       val find : t -> Locations.Zone.t -> v       val filter_base : (Base.t -> bool) -> t -> t       val map : (v -> v) -> t -> t       val fold : (Locations.Zone.t -> v -> '-> 'a) -> map -> '-> 'a       val fold_base : (Base.t -> LOffset.t -> '-> 'a) -> map -> '-> 'a       val fold_fuse_same :         (Locations.Zone.t -> v -> '-> 'a) -> map -> '-> 'a       val fold_join_zone :         both:(Int_Intervals.t -> LOffset.t -> 'a) ->         conv:(Base.t -> '-> 'b) ->         empty_map:(Locations.Zone.t -> 'b) ->         join:('-> '-> 'b) -> empty:'-> Locations.Zone.t -> map -> 'b       val map2 :         cache:Hptmap_sig.cache_type ->         symmetric:bool ->         idempotent:bool ->         empty_neutral:bool ->         (LOffset.t -> LOffset.t -> LOffset.map2_decide) ->         (v -> v -> v) -> map -> map -> map       val shape : map -> LOffset.t Hptmap.Shape(Base.Base).t       val imprecise_write_msg : string ref       val clear_caches : unit -> unit     end   type data_state = {     loc_info : PdgTypes.LocInfo.t;     under_outputs : Locations.Zone.t;   }   module Pdg :     sig       exception Top       exception Bottom       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 : Kernel_function.t -> t       val bottom : Kernel_function.t -> t       val is_top : t -> bool       val is_bottom : t -> bool       val get_kf : t -> Kernel_function.t       val iter_nodes : (PdgTypes.Node.t -> unit) -> t -> unit       val fold_call_nodes :         ('-> PdgTypes.Node.t -> 'a) -> '-> t -> Cil_types.stmt -> 'a       val iter_direct_dpds :         t -> (PdgTypes.Node.t -> unit) -> PdgTypes.Node.t -> unit       val iter_direct_codpds :         t -> (PdgTypes.Node.t -> unit) -> PdgTypes.Node.t -> unit       type dpd_info = PdgTypes.Node.t * Locations.Zone.t option       val get_all_direct_dpds :         t -> PdgTypes.Node.t -> PdgTypes.Pdg.dpd_info list       val get_x_direct_dpds :         PdgTypes.Dpd.td -> t -> PdgTypes.Node.t -> PdgTypes.Pdg.dpd_info list       val get_all_direct_codpds :         t -> PdgTypes.Node.t -> PdgTypes.Pdg.dpd_info list       val get_x_direct_codpds :         PdgTypes.Dpd.td -> t -> PdgTypes.Node.t -> PdgTypes.Pdg.dpd_info list       val fold_direct_dpds :         t ->         ('->          PdgTypes.Dpd.t * Locations.Zone.t option -> PdgTypes.Node.t -> 'a) ->         '-> PdgTypes.Node.t -> 'a       val fold_direct_codpds :         t ->         ('->          PdgTypes.Dpd.t * Locations.Zone.t option -> PdgTypes.Node.t -> 'a) ->         '-> PdgTypes.Node.t -> 'a       val pretty_bw : ?bw:bool -> Format.formatter -> t -> unit       val pretty_graph : ?bw:bool -> Format.formatter -> PdgTypes.G.t -> unit       type fi = (PdgTypes.Node.t, unit) PdgIndex.FctIndex.t       val get_index : t -> PdgTypes.Pdg.fi       val make :         Kernel_function.t ->         PdgTypes.G.t ->         PdgTypes.data_state Cil_datatype.Stmt.Hashtbl.t ->         PdgTypes.Pdg.fi -> t       val get_states : t -> PdgTypes.data_state Cil_datatype.Stmt.Hashtbl.t       val build_dot : string -> t -> unit       module Printer :         sig           val iter_vertex : (PdgTypes.Node.t -> unit) -> t -> unit           val iter_edges_e : (PdgTypes.G.E.t * bool -> unit) -> t -> unit           val graph_attributes : t -> Graph.Graphviz.DotAttributes.graph list           val default_vertex_attributes :             t -> Graph.Graphviz.DotAttributes.vertex list           val vertex_name : PdgTypes.Node.t -> string           val vertex_attributes :             PdgTypes.Node.t -> Graph.Graphviz.DotAttributes.vertex list           val get_subgraph :             PdgTypes.Node.t -> Graph.Graphviz.DotAttributes.subgraph option           val default_edge_attributes :             '-> Graph.Graphviz.DotAttributes.edge list           val edge_attributes :             PdgTypes.G.E.t * bool -> Graph.Graphviz.DotAttributes.edge list         end     end end