sig
  module MakeNode :
    functor
      (M : sig
             val kf : Kernel_function.t
             type abstract_value
             val compile_node :
               Cil_types.stmt ->
               Region_analysis_stmt.MakeNode.abstract_value ->
               (Cil_types.stmt Region_analysis.edge *
                Region_analysis_stmt.MakeNode.abstract_value)
               list
             val mu :
               (Region_analysis_stmt.MakeNode.abstract_value ->
                Region_analysis_stmt.MakeNode.abstract_value) ->
               Region_analysis_stmt.MakeNode.abstract_value ->
               Region_analysis_stmt.MakeNode.abstract_value
             val join :
               Region_analysis_stmt.MakeNode.abstract_value list ->
               Region_analysis_stmt.MakeNode.abstract_value
           end->
      sig
        type node = Cil_types.stmt
        val pretty : Format.formatter -> node -> unit
        module Dict :
          sig
            type 'a t
            val create : int -> '-> 'a t
            val get : 'a t -> node -> 'a
            val set : 'a t -> node -> '-> unit
            val iter : 'a t -> (node -> '-> unit) -> unit
            val copy : 'a t -> 'a t
          end
        module Set :
          sig
            type elt = node
            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 find : elt -> t -> elt
            val of_list : elt list -> t
          end
        module Graph :
          sig
            val iter_succs : node -> (node -> unit) -> unit
            val iter_preds : node -> (node -> unit) -> unit
            val all_nodes : Set.t
            val entry_node : node
            val exit_nodes : node list
          end
        module DomTree :
          sig
            val dominates : node -> node -> bool
            val domtree_postfix_iter : (node -> unit) -> unit
          end
        module Edge_Dict :
          sig
            type 'a t
            val set : 'a t -> node Region_analysis.edge -> '-> unit
            val get : 'a t -> node Region_analysis.edge -> 'a
            val create : unit -> 'a t
            val iter :
              'a t -> (node Region_analysis.edge -> '-> unit) -> unit
          end
        type abstract_value = M.abstract_value
        val compile_node :
          node ->
          abstract_value -> (node Region_analysis.edge * abstract_value) list
        val join : abstract_value list -> abstract_value
        val mu :
          (abstract_value -> abstract_value) ->
          abstract_value -> abstract_value
      end
end