val dummy_region : Jc_env.region
val is_dummy_region : Jc_env.region -> bool
module InternalRegion :
  sig
    type t = Jc_env.region
    val equal : Jc_env.region -> Jc_env.region -> bool
    val compare : Jc_env.region -> Jc_env.region -> int
    val hash : Jc_env.region -> int
    val prefer : Jc_env.region -> Jc_env.region -> int
  end
module UnionFind :
  functor
    (Elem : sig
              type t
              val equal : t -> t -> bool
              val prefer : t -> t -> int
            end) ->
    functor
      (ElemTable : sig
                     type key = Elem.t
                     type 'a t
                     val create : int -> 'a t
                     val clear : 'a t -> unit
                     val copy : 'a t -> 'a t
                     val add : 'a t -> key -> 'a -> 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 -> 'a -> unit
                     val mem : 'a t -> key -> bool
                     val iter : (key -> 'a -> unit) -> 'a t -> unit
                     val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
                     val length : 'a t -> int
                   end) ->
      sig
        val table : ElemTable.key ElemTable.t
        val ranks : int ElemTable.t
        val repr : ElemTable.key -> ElemTable.key
        val rank : ElemTable.key -> int
        val unify : ElemTable.key -> ElemTable.key -> unit
      end
module RegionTable :
  sig
    type key = InternalRegion.t
    type 'a t = 'a Hashtbl.Make(InternalRegion).t
    val create : int -> 'a t
    val clear : 'a t -> unit
    val copy : 'a t -> 'a t
    val add : 'a t -> key -> 'a -> 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 -> 'a -> unit
    val mem : 'a t -> key -> bool
    val iter : (key -> 'a -> unit) -> 'a t -> unit
    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
    val length : 'a t -> int
  end
module RegionSet :
  sig
    type elt = InternalRegion.t
    type t = Set.Make(InternalRegion).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 -> 'a) -> t -> 'a -> '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 PairOrd :
  functor (A : Set.OrderedType) ->
    functor (B : Set.OrderedType) ->
      sig type t = A.t * B.t val compare : A.t * B.t -> A.t * B.t -> int end
module RegionUF :
  sig
    val table : RegionTable.key RegionTable.t
    val ranks : int RegionTable.t
    val repr : RegionTable.key -> RegionTable.key
    val rank : RegionTable.key -> int
    val unify : RegionTable.key -> RegionTable.key -> unit
  end
module FieldOrVariantRegion :
  sig
    type t = Jc_envset.FieldOrVariantOrd.t * InternalRegion.t
    val compare :
      Jc_envset.FieldOrVariantOrd.t * InternalRegion.t ->
      Jc_envset.FieldOrVariantOrd.t * InternalRegion.t -> int
  end
module StringRegion :
  sig
    type t = String.t * InternalRegion.t
    val compare :
      String.t * InternalRegion.t -> String.t * InternalRegion.t -> int
  end
module PairRegionSet :
  functor (T : sig type t end) ->
    functor
      (P : sig type t = T.t * Jc_env.region val compare : t -> t -> int end) ->
      sig
        module S :
          sig
            type elt = P.t
            type t = Set.Make(P).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 -> 'a) -> t -> 'a -> '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
        type elt = P.t
        type t = Set.Make(P).t
        val empty : t
        val is_empty : t -> bool
        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 -> 'a) -> t -> 'a -> '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 mem : T.t * RegionTable.key -> S.t -> bool
        val add : T.t * RegionTable.key -> S.t -> S.t
        val singleton : T.t * RegionTable.key -> S.t
        val remove : T.t * RegionTable.key -> S.t -> S.t
        val split : T.t * RegionTable.key -> S.t -> S.t * bool * S.t
        val map_repr : S.t -> S.t
      end
module FieldOrVariantRegionSet :
  sig
    module S :
      sig
        type elt = FieldOrVariantRegion.t
        type t = Set.Make(FieldOrVariantRegion).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 -> 'a) -> t -> 'a -> '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
    type elt = FieldOrVariantRegion.t
    type t = Set.Make(FieldOrVariantRegion).t
    val empty : t
    val is_empty : t -> bool
    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 -> 'a) -> t -> 'a -> '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 mem : Jc_envset.FieldOrVariantOrd.t * RegionTable.key -> S.t -> bool
    val add : Jc_envset.FieldOrVariantOrd.t * RegionTable.key -> S.t -> S.t
    val singleton : Jc_envset.FieldOrVariantOrd.t * RegionTable.key -> S.t
    val remove :
      Jc_envset.FieldOrVariantOrd.t * RegionTable.key -> S.t -> S.t
    val split :
      Jc_envset.FieldOrVariantOrd.t * RegionTable.key ->
      S.t -> S.t * bool * S.t
    val map_repr : S.t -> S.