sig
  val docHash :
    ?sep:Pretty_utils.sformat ->
    ('a, 'b) Pretty_utils.formatter2 ->
    ('a, 'b) Hashtbl.t Pretty_utils.formatter
  val hash_to_list : ('a, 'b) Hashtbl.t -> ('a * 'b) list
  val keys : ('a, 'b) Hashtbl.t -> 'a list
  val ( $ ) : ('-> 'b) -> ('-> 'a) -> '-> 'b
  val swap : ('-> '-> 'c) -> '-> '-> 'c
  val hash_copy_into : ('a, 'b) Hashtbl.t -> ('a, 'b) Hashtbl.t -> unit
  val anticompare : '-> '-> int
  val list_drop : int -> 'a list -> 'a list
  val list_droptail : int -> 'a list -> 'a list
  val list_span : ('-> bool) -> 'a list -> 'a list * 'a list
  val list_insert_by : ('-> '-> int) -> '-> 'a list -> 'a list
  val list_head_default : '-> 'a list -> 'a
  val list_iter3 :
    ('-> '-> '-> unit) -> 'a list -> 'b list -> 'c list -> unit
  val get_some_option_list : 'a option list -> 'a list
  val list_append : 'a list -> 'a list -> 'a list
  val list_iteri : (int -> '-> unit) -> 'a list -> unit
  val list_mapi : (int -> '-> 'b) -> 'a list -> 'b list
  val list_fold_lefti : ('-> int -> '-> 'a) -> '-> 'b list -> 'a
  val int_range_list : int -> int -> int list
  val list_init : int -> (int -> 'a) -> 'a list
  val list_find_first : 'a list -> ('-> 'b option) -> 'b option
  val list_last : 'a list -> 'a
  val mapNoCopy : ('-> 'a) -> 'a list -> 'a list
  val mapNoCopyList : ('-> 'a list) -> 'a list -> 'a list
  val filterNoCopy : ('-> bool) -> 'a list -> 'a list
  val joinStrings : string -> string list -> string
  val hasPrefix : string -> string -> bool
  val restoreRef : ?deepCopy:('-> 'a) -> 'Pervasives.ref -> unit -> unit
  val restoreHash :
    ?deepCopy:('-> 'a) -> ('b, 'a) Hashtbl.t -> unit -> unit
  val restoreIntHash : ?deepCopy:('-> 'a) -> 'Inthash.t -> unit -> unit
  val restoreArray : ?deepCopy:('-> 'a) -> 'a array -> unit -> unit
  val runThunks : (unit -> unit) list -> unit -> unit
  val memoize : ('a, 'b) Hashtbl.t -> '-> ('-> 'b) -> 'b
  val findOrAdd : ('a, 'b) Hashtbl.t -> '-> ('-> 'b) -> 'b
  val tryFinally : ('-> 'b) -> ('b option -> unit) -> '-> 'b
  val valOf : 'a option -> 'a
  val out_some : 'a option -> 'a
  val opt_bind : ('-> 'b option) -> 'a option -> 'b option
  val opt_app : ('-> 'b) -> '-> 'a option -> 'b
  val opt_iter : ('-> unit) -> 'a option -> unit
  val fold_for : init:'-> lo:int -> hi:int -> (int -> '-> 'a) -> 'a
  module type STACK =
    sig
      type 'a t
      exception Empty
      val create : unit -> 'Cilutil.STACK.t
      val push : '-> 'Cilutil.STACK.t -> unit
      val pop : 'Cilutil.STACK.t -> 'a
      val top : 'Cilutil.STACK.t -> 'a
      val clear : 'Cilutil.STACK.t -> unit
      val copy : 'Cilutil.STACK.t -> 'Cilutil.STACK.t
      val is_empty : 'Cilutil.STACK.t -> bool
      val length : 'Cilutil.STACK.t -> int
      val iter : ('-> unit) -> 'Cilutil.STACK.t -> unit
    end
  module Stack : STACK
  type configData =
      ConfInt of int
    | ConfBool of bool
    | ConfFloat of float
    | ConfString of string
    | ConfList of Cilutil.configData list
  val loadConfiguration : string -> unit
  val saveConfiguration : string -> unit
  val clearConfiguration : unit -> unit
  val setConfiguration : string -> Cilutil.configData -> unit
  val findConfiguration : string -> Cilutil.configData
  val findConfigurationInt : string -> int
  val useConfigurationInt : string -> (int -> unit) -> unit
  val findConfigurationBool : string -> bool
  val useConfigurationBool : string -> (bool -> unit) -> unit
  val findConfigurationString : string -> string
  val useConfigurationString : string -> (string -> unit) -> unit
  val findConfigurationList : string -> Cilutil.configData list
  val useConfigurationList :
    string -> (Cilutil.configData list -> unit) -> unit
  type symbol = int
  val symbolName : Cilutil.symbol -> string
  val registerSymbolName : string -> Cilutil.symbol
  val registerSymbolRange : int -> (int -> string) -> Cilutil.symbol
  val newSymbol : string -> Cilutil.symbol
  val resetSymbols : unit -> unit
  val snapshotSymbols : unit -> unit -> unit
  val dumpSymbols : unit -> unit
  module Int32Op :
    sig
      val ( <% ) : int32 -> int32 -> bool
      val ( <=% ) : int32 -> int32 -> bool
      val ( >% ) : int32 -> int32 -> bool
      val ( >=% ) : int32 -> int32 -> bool
      val ( <>% ) : int32 -> int32 -> bool
      val ( +% ) : int32 -> int32 -> int32
      val ( -% ) : int32 -> int32 -> int32
      val ( *% ) : int32 -> int32 -> int32
      val ( /% ) : int32 -> int32 -> int32
      val ( ~-% ) : int32 -> int32
      val sll : int32 -> int32 -> int32
      val ( >>% ) : int32 -> int32 -> int32
      val ( >>>% ) : int32 -> int32 -> int32
      exception IntegerTooLarge
      val to_int : int32 -> int
    end
  val equals : '-> '-> bool
  val locUnknown : Cil_types.location
  val get_instrLoc : Cil_types.instr -> Cil_types.location
  val get_globalLoc : Cil_types.global -> Cil_types.location
  val get_stmtLoc : Cil_types.stmtkind -> Cil_types.location
  val get_code_annotationLoc :
    Cil_types.code_annotation -> Cil_types.location option
  module StringMap :
    sig
      type key = String.t
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
    end
  module StringSet :
    sig
      type elt = String.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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val pretty : Format.formatter -> t -> unit
    end
  module type Mapl =
    sig
      type key
      type +'a t
      type 'a map = 'a list Cilutil.Mapl.t
      val empty : 'Cilutil.Mapl.t
      val is_empty : 'Cilutil.Mapl.t -> bool
      val add :
        Cilutil.Mapl.key ->
        '-> 'a list Cilutil.Mapl.t -> 'a list Cilutil.Mapl.t
      val find : Cilutil.Mapl.key -> 'a list Cilutil.Mapl.t -> 'a list
      val remove : Cilutil.Mapl.key -> 'Cilutil.Mapl.t -> 'Cilutil.Mapl.t
      val mem : Cilutil.Mapl.key -> 'Cilutil.Mapl.t -> bool
      val iter :
        (Cilutil.Mapl.key -> '-> unit) -> 'Cilutil.Mapl.t -> unit
      val map : ('-> 'b) -> 'Cilutil.Mapl.t -> 'Cilutil.Mapl.t
      val mapi :
        (Cilutil.Mapl.key -> '-> 'b) ->
        'Cilutil.Mapl.t -> 'Cilutil.Mapl.t
      val fold :
        (Cilutil.Mapl.key -> '-> '-> 'b) -> 'Cilutil.Mapl.t -> '-> 'b
      val compare :
        ('-> '-> int) -> 'Cilutil.Mapl.t -> 'Cilutil.Mapl.t -> int
      val equal :
        ('-> '-> bool) -> 'Cilutil.Mapl.t -> 'Cilutil.Mapl.t -> bool
    end
  module Mapl_Make :
    functor (X : Map.OrderedType->
      sig
        type key = X.t
        type +'a t
        type 'a map = 'a list t
        val empty : 'a t
        val is_empty : 'a t -> bool
        val add : key -> '-> 'a list t -> 'a list t
        val find : key -> 'a list t -> 'a list
        val remove : key -> 'a t -> 'a t
        val mem : key -> 'a t -> bool
        val iter : (key -> '-> unit) -> 'a t -> unit
        val map : ('-> 'b) -> 'a t -> 'b t
        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
        val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
        val compare : ('-> '-> int) -> 'a t -> 'a t -> int
        val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      end
  module IntMapl :
    sig
      type key = int
      type 'a map
      val empty : 'Cilutil.IntMapl.map
      val add :
        Cilutil.IntMapl.key ->
        '-> 'Cilutil.IntMapl.map -> 'Cilutil.IntMapl.map
      val find : Cilutil.IntMapl.key -> 'Cilutil.IntMapl.map -> 'a list
    end
  module Instr :
    sig
      type t = Cil_types.kinstr
      val compare : Cilutil.Instr.t -> Cilutil.Instr.t -> int
      val equal : Cilutil.Instr.t -> Cilutil.Instr.t -> bool
      val hash : Cilutil.Instr.t -> int
      val pretty : Format.formatter -> Cilutil.Instr.t -> unit
      val loc : Cilutil.Instr.t -> Cil_types.location
    end
  module InstrMapl :
    sig
      type key = Cil_types.kinstr
      type +'a t
      type 'a map = 'a list t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a list t -> 'a list t
      val find : key -> 'a list t -> 'a list
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
    end
  module InstrHashtbl :
    sig
      type key = Cil_types.kinstr
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
    end
  module StmtMap :
    sig
      type key = Cil_types.stmt
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val pretty :
        (Format.formatter -> '-> unit) -> Format.formatter -> 'a t -> unit
      val descr : Unmarshal.t -> Unmarshal.t
    end
  module StmtSet :
    sig
      type elt = Cil_types.stmt
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val pretty : Format.formatter -> t -> unit
      val descr : Unmarshal.t
    end
  module StmtComparable :
    sig
      type t = Cil_types.stmt
      val compare : t -> t -> int
      val hash : t -> int
      val equal : t -> t -> bool
      val descr : Unmarshal.t
    end
  module StmtHashtbl :
    sig
      type key = Cil_types.stmt
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
      val pretty : Format.formatter -> 'a t -> unit
    end
  module KinstrComparable :
    sig
      type t = Cil_types.kinstr
      val compare : t -> t -> int
      val hash : t -> int
      val equal : t -> t -> bool
    end
  module VarinfoComparable :
    sig
      type t = Cil_types.varinfo
      val compare :
        Cilutil.VarinfoComparable.t -> Cilutil.VarinfoComparable.t -> int
      val hash : Cilutil.VarinfoComparable.t -> int
      val equal :
        Cilutil.VarinfoComparable.t -> Cilutil.VarinfoComparable.t -> bool
    end
  module VarinfoHashtbl :
    sig
      type key = Cil_types.varinfo
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
    end
  module VarinfoMap :
    sig
      type key = Cil_types.varinfo
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
    end
  module VarinfoSet :
    sig
      type elt = Cil_types.varinfo
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
    end
  module EnuminfoComparable :
    sig
      type t = Cil_types.enuminfo
      val compare :
        Cilutil.EnuminfoComparable.t -> Cilutil.EnuminfoComparable.t -> int
      val hash : Cilutil.EnuminfoComparable.t -> int
      val equal :
        Cilutil.EnuminfoComparable.t -> Cilutil.EnuminfoComparable.t -> bool
    end
  module EnuminfoHashtbl :
    sig
      type key = Cil_types.enuminfo
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
    end
  module EnuminfoMap :
    sig
      type key = Cil_types.enuminfo
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
    end
  module EnuminfoSet :
    sig
      type elt = Cil_types.enuminfo
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
    end
  module EnumitemComparable :
    sig
      type t = Cil_types.enumitem
      val compare :
        Cilutil.EnumitemComparable.t -> Cilutil.EnumitemComparable.t -> int
      val hash : Cilutil.EnumitemComparable.t -> int
      val equal :
        Cilutil.EnumitemComparable.t -> Cilutil.EnumitemComparable.t -> bool
    end
  module CompinfoComparable :
    sig
      type t = Cil_types.compinfo
      val compare :
        Cilutil.CompinfoComparable.t -> Cilutil.CompinfoComparable.t -> int
      val hash : Cilutil.CompinfoComparable.t -> int
      val equal :
        Cilutil.CompinfoComparable.t -> Cilutil.CompinfoComparable.t -> bool
    end
  module TypeinfoComparable :
    sig
      type t = Cil_types.typeinfo
      val compare :
        Cilutil.TypeinfoComparable.t -> Cilutil.TypeinfoComparable.t -> int
      val hash : Cilutil.TypeinfoComparable.t -> int
      val equal :
        Cilutil.TypeinfoComparable.t -> Cilutil.TypeinfoComparable.t -> bool
    end
  module TypeinfoHashtbl :
    sig
      type key = Cil_types.typeinfo
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
    end
  module TypeinfoMap :
    sig
      type key = Cil_types.typeinfo
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
    end
  module TypeinfoSet :
    sig
      type elt = Cil_types.typeinfo
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
    end
  module LogicVarComparable :
    sig
      type t = Cil_types.logic_var
      val compare :
        Cilutil.LogicVarComparable.t -> Cilutil.LogicVarComparable.t -> int
      val hash : Cilutil.LogicVarComparable.t -> int
      val equal :
        Cilutil.LogicVarComparable.t -> Cilutil.LogicVarComparable.t -> bool
    end
  module LogicVarHashtbl :
    sig
      type key = Cil_types.logic_var
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
    end
  module LogicVarMap :
    sig
      type key = Cil_types.logic_var
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
    end
  module LogicVarSet :
    sig
      type elt = Cil_types.logic_var
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
    end
  module FieldinfoComparable :
    sig
      type t = Cil_types.fieldinfo
      val compare :
        Cilutil.FieldinfoComparable.t -> Cilutil.FieldinfoComparable.t -> int
      val hash : Cilutil.FieldinfoComparable.t -> int
      val equal :
        Cilutil.FieldinfoComparable.t ->
        Cilutil.FieldinfoComparable.t -> bool
    end
  module FieldinfoHashtbl :
    sig
      type key = Cil_types.fieldinfo
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
    end
  module FieldinfoSet :
    sig
      type elt = Cil_types.fieldinfo
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
    end
  module FieldinfoMap :
    sig
      type key = Cil_types.fieldinfo
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
    end
  val pTypeSig : (Cil_types.typ -> Cil_types.typsig) Pervasives.ref
  module TypeComparable :
    sig
      type t = Cil_types.typ
      val compare :
        Cilutil.TypeComparable.t -> Cilutil.TypeComparable.t -> int
      val hash : Cilutil.TypeComparable.t -> int
      val equal :
        Cilutil.TypeComparable.t -> Cilutil.TypeComparable.t -> bool
    end
  module TypeHashtbl :
    sig
      type key = Cil_types.typ
      type 'a t
      val create : int -> 'a t
      val clear : '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 fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
    end
  module TypeSet :
    sig
      type elt = Cil_types.typ
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
    end
  module LvalComparable :
    sig
      type t = Cil_types.lval
      val compare :
        Cilutil.LvalComparable.t -> Cilutil.LvalComparable.t -> int
    end
  module LvalSet :
    sig
      type elt = Cil_types.lval
      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 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 min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
    end
  val printStages : bool Pervasives.ref
  val print_list :
    (Format.formatter -> unit -> unit) ->
    (Format.formatter -> '-> unit) -> Format.formatter -> 'a list -> unit
  val print_if :
    bool -> Format.formatter -> (Format.formatter -> unit -> unit) -> unit
  val comma : Format.formatter -> unit -> unit
  val underscore : Format.formatter -> unit -> unit
  val semi : Format.formatter -> unit -> unit
  val space : Format.formatter -> unit -> unit
  val alt : Format.formatter -> unit -> unit
  val newline : Format.formatter -> unit -> unit
  val arrow : Format.formatter -> unit -> unit
  val nothing : Format.formatter -> unit -> unit
  val pretty_list :
    (Format.formatter -> unit) ->
    (Format.formatter -> '-> unit) -> Format.formatter -> 'a list -> unit
  val pretty_list_del :
    (Format.formatter -> unit) ->
    (Format.formatter -> unit) ->
    (Format.formatter -> unit) ->
    (Format.formatter -> '-> unit) -> Format.formatter -> 'a list -> unit
  val pretty_opt :
    (Format.formatter -> '-> unit) -> Format.formatter -> 'a option -> unit
  val pretty_opt_nl :
    (Format.formatter -> '-> unit) -> Format.formatter -> 'a option -> unit
  val space_sep : string -> Format.formatter -> unit
  val nl_sep : Format.formatter -> unit
  type opaque_term_env = {
    term_lhosts : Cil_types.term_lhost Cilutil.VarinfoMap.t;
    terms : Cil_types.term Cilutil.VarinfoMap.t;
    vars : Cil_types.logic_var Cilutil.VarinfoMap.t;
  }
  type opaque_exp_env = { exps : Cil_types.exp Cilutil.VarinfoMap.t; }
end