sig
  type 'node edge = Edge of 'node * 'node | Exit of 'node
  module type Node =
    sig
      type node
      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 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
        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 edge -> '-> unit
          val get : 'a t -> node edge -> 'a
          val create : unit -> 'a t
          val iter : 'a t -> (node edge -> '-> unit) -> unit
        end
      type abstract_value
      val compile_node :
        node -> abstract_value -> (node edge * abstract_value) list
      val join : abstract_value list -> abstract_value
      val mu :
        (abstract_value -> abstract_value) ->
        abstract_value -> abstract_value
    end
  module Make :
    functor (N : Node->
      sig val after : N.abstract_value -> N.abstract_value N.Edge_Dict.t end
end