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 : Stdlib.Format.formatter -> PdgTypes.Dpd.td -> unit
      val pretty : Stdlib.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 disjoint : t -> t -> bool
          val diff : t -> t -> t
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val map : (elt -> elt) -> t -> t
          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 filter_map : (elt -> elt option) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_list : elt list -> t
          val to_seq_from : elt -> t -> elt Seq.t
          val to_seq : t -> elt Seq.t
          val to_rev_seq : t -> elt Seq.t
          val add_seq : elt Seq.t -> t -> t
          val of_seq : elt Seq.t -> t
          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 update : key -> ('a option -> 'a option) -> '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 union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a 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 to_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_keys : 'a t -> key Seq.t
          val to_seq_values : 'a t -> 'Seq.t
          val add_seq : 'a t -> (key * 'a) Seq.t -> unit
          val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
          val of_seq : (key * 'a) Seq.t -> 'a t
          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 find_opt : 'a t -> key -> 'a option
          val find_def : 'a t -> key -> '-> 'a
          val memo : 'a t -> key -> (key -> 'a) -> 'a
          val structural_descr : Structural_descr.t -> Structural_descr.t
          val make_type : 'Type.t -> 'a t Type.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
      val id : t -> int
      val elem_key : t -> PdgIndex.Key.t
      val stmt : t -> Cil_types.stmt option
      val pretty_list : Stdlib.Format.formatter -> t list -> unit
      val pretty_with_part :
        Stdlib.Format.formatter -> t * Locations.Zone.t option -> unit
      val pretty_node : Stdlib.Format.formatter -> t -> unit
    end
  module NodeSet :
    sig
      type 'a map
      type t = unit map
      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 disjoint : t -> t -> bool
          val diff : t -> t -> t
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val map : (elt -> elt) -> t -> t
          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 filter_map : (elt -> elt option) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_list : elt list -> t
          val to_seq_from : elt -> t -> elt Seq.t
          val to_seq : t -> elt Seq.t
          val to_rev_seq : t -> elt Seq.t
          val add_seq : elt Seq.t -> t -> t
          val of_seq : elt Seq.t -> t
          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 update : key -> ('a option -> 'a option) -> '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 union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a 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 to_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_keys : 'a t -> key Seq.t
          val to_seq_values : 'a t -> 'Seq.t
          val add_seq : 'a t -> (key * 'a) Seq.t -> unit
          val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
          val of_seq : (key * 'a) Seq.t -> 'a t
          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 find_opt : 'a t -> key -> 'a option
          val find_def : 'a t -> key -> '-> 'a
          val memo : 'a t -> key -> (key -> 'a) -> 'a
          val structural_descr : Structural_descr.t -> Structural_descr.t
          val make_type : 'Type.t -> 'a t Type.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
      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 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
      val from_map : 'a map -> t
      val fold2_join_heterogeneous :
        cache:Hptmap_sig.cache_type ->
        empty_left:('a map -> 'b) ->
        empty_right:(t -> 'b) ->
        both:(elt -> '-> 'b) ->
        join:('-> '-> 'b) -> empty:'-> t -> 'a map -> 'b
      val replace : elt map -> t -> bool * t
      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 find : elt -> t -> elt
          val of_list : elt list -> 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
      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 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 filter : (O.elt -> bool) -> t -> t
      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 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 : exact:bool -> t -> Locations.Zone.t -> v -> t
      val add_binding_loc : 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 -> Stdlib.Format.formatter -> t -> unit
      val pretty_graph :
        ?bw:bool -> Stdlib.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