sig
  module Apronexpr :
    sig
      type 'a symbol =
        'a Bdd.Env.symbol = {
        compare : 'a -> 'a -> int;
        marshal : 'a -> string;
        unmarshal : string -> 'a;
        mutable print : Format.formatter -> 'a -> unit;
      }
      type typ = [ `Int | `Real ]
      type ('a, 'b) typ_of_var = 'a -> 'b
        constraint 'b = [> Bddapron.Apronexpr.typ ]
      module Lin :
        sig
          type 'a term = Mpqf.t * 'a
          type 'a t = {
            cst : Mpqf.t;
            lterm : 'a Bddapron.Apronexpr.Lin.term list;
          }
          val normalize :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Lin.t
          val compare_lterm :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Lin.term list ->
            'a Bddapron.Apronexpr.Lin.term list -> int
          val compare :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Lin.t -> int
          val var : 'a -> 'a Bddapron.Apronexpr.Lin.t
          val zero : 'a Bddapron.Apronexpr.Lin.t
          val one : 'a Bddapron.Apronexpr.Lin.t
          val cst : Mpqf.t -> 'a Bddapron.Apronexpr.Lin.t
          val add :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Lin.t ->
            'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Lin.t
          val sub :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Lin.t ->
            'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Lin.t
          val scale :
            Mpqf.t ->
            'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Lin.t
          val negate :
            'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Lin.t
          val support :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Lin.t -> 'a PSette.t
          val substitute_by_var :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Lin.t ->
            ('a, 'a) PMappe.t -> 'a Bddapron.Apronexpr.Lin.t
          val normalize_as_constraint :
            'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Lin.t
          val print :
            'a Bddapron.Apronexpr.symbol ->
            Format.formatter -> 'a Bddapron.Apronexpr.Lin.t -> unit
          val of_linexpr0 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Environment.t ->
            Apron.Linexpr0.t -> 'a Bddapron.Apronexpr.Lin.t
          val of_linexpr1 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Linexpr1.t -> 'a Bddapron.Apronexpr.Lin.t
          val to_linexpr0 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Environment.t ->
            'a Bddapron.Apronexpr.Lin.t -> Apron.Linexpr0.t
          val to_linexpr1 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Environment.t ->
            'a Bddapron.Apronexpr.Lin.t -> Apron.Linexpr1.t
        end
      module Poly :
        sig
          type 'a varexp = 'a * int
          type 'a monomial = 'a Bddapron.Apronexpr.Poly.varexp list
          type 'a term = Mpqf.t * 'a Bddapron.Apronexpr.Poly.monomial
          type 'a t = 'a Bddapron.Apronexpr.Poly.term list
          val compare_varexp :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.varexp ->
            'a Bddapron.Apronexpr.Poly.varexp -> int
          val compare_monomial :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.monomial ->
            'a Bddapron.Apronexpr.Poly.monomial -> int
          val normalize_monomial :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.monomial ->
            'a Bddapron.Apronexpr.Poly.monomial
          val normalize :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val normalize_full :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val compare :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t ->
            'a Bddapron.Apronexpr.Poly.t -> int
          val cst : Mpqf.t -> 'a Bddapron.Apronexpr.Poly.t
          val var : 'a -> 'a Bddapron.Apronexpr.Poly.t
          val add :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t ->
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val sub :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t ->
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val scale :
            'a Bddapron.Apronexpr.symbol ->
            Mpqf.t * 'a Bddapron.Apronexpr.Poly.monomial ->
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val mul :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t ->
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val div :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t ->
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val negate :
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val support :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t -> 'a PSette.t
          val substitute_by_var :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Poly.t ->
            ('a, 'a) PMappe.t -> 'a Bddapron.Apronexpr.Poly.t
          val normalize_as_constraint :
            'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Poly.t
          val print :
            'a Bddapron.Apronexpr.symbol ->
            Format.formatter -> 'a Bddapron.Apronexpr.Poly.t -> unit
        end
      module Tree :
        sig
          type unop = Apron.Texpr1.unop = Neg | Cast | Sqrt
          type binop = Apron.Texpr1.binop = Add | Sub | Mul | Div | Mod | Pow
          type typ =
            Apron.Texpr1.typ =
              Real
            | Int
            | Single
            | Double
            | Extended
            | Quad
          type round = Apron.Texpr1.round = Near | Zero | Up | Down | Rnd
          type 'a t =
              Cst of Apron.Coeff.t
            | Var of 'a
            | Unop of Bddapron.Apronexpr.Tree.unop *
                'a Bddapron.Apronexpr.Tree.t * Bddapron.Apronexpr.Tree.typ *
                Bddapron.Apronexpr.Tree.round
            | Binop of Bddapron.Apronexpr.Tree.binop *
                'a Bddapron.Apronexpr.Tree.t * 'a Bddapron.Apronexpr.Tree.t *
                Bddapron.Apronexpr.Tree.typ * Bddapron.Apronexpr.Tree.round
          val support :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Tree.t -> 'a PSette.t
          val substitute_by_var :
            'a Bddapron.Apronexpr.Tree.t ->
            ('a, 'a) PMappe.t -> 'a Bddapron.Apronexpr.Tree.t
          val print :
            'a Bddapron.Apronexpr.symbol ->
            Format.formatter -> 'a Bddapron.Apronexpr.Tree.t -> unit
          val compare :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Tree.t ->
            'a Bddapron.Apronexpr.Tree.t -> int
          val of_expr :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Texpr1.expr -> 'a Bddapron.Apronexpr.Tree.t
          val to_expr :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Tree.t -> Apron.Texpr1.expr
        end
      val lin_of_poly :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Lin.t
      val lin_of_tree :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.Tree.t -> 'a Bddapron.Apronexpr.Lin.t
      val poly_of_tree :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.Tree.t -> 'a Bddapron.Apronexpr.Poly.t
      val tree_of_lin :
        'a Bddapron.Apronexpr.Lin.t -> 'a Bddapron.Apronexpr.Tree.t
      val tree_of_poly :
        'a Bddapron.Apronexpr.Poly.t -> 'a Bddapron.Apronexpr.Tree.t
      type 'a t =
          Lin of 'a Bddapron.Apronexpr.Lin.t
        | Poly of 'a Bddapron.Apronexpr.Poly.t
        | Tree of 'a Bddapron.Apronexpr.Tree.t
      type 'a expr = 'a Bddapron.Apronexpr.t
      val var :
        'a Bddapron.Apronexpr.symbol ->
        ('a, [> Bddapron.Apronexpr.typ ]) Bddapron.Apronexpr.typ_of_var ->
        'a -> 'a Bddapron.Apronexpr.t
      val zero : 'a Bddapron.Apronexpr.t
      val one : 'a Bddapron.Apronexpr.t
      val cst : Apron.Coeff.t -> 'a Bddapron.Apronexpr.t
      val add :
        'a Bddapron.Apronexpr.symbol ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.Apronexpr.t ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val sub :
        'a Bddapron.Apronexpr.symbol ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.Apronexpr.t ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val mul :
        'a Bddapron.Apronexpr.symbol ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.Apronexpr.t ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val div :
        'a Bddapron.Apronexpr.symbol ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.Apronexpr.t ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val gmod :
        'a Bddapron.Apronexpr.symbol ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.Apronexpr.t ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val negate : 'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val cast :
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val sqrt :
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val support :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.t -> 'a PSette.t
      val substitute_by_var :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.t ->
        ('a, 'a) PMappe.t -> 'a Bddapron.Apronexpr.t
      val normalize :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val equal :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t -> bool
      val hash :
        'a Bddapron.Apronexpr.symbol -> 'a Bddapron.Apronexpr.t -> int
      val compare :
        'a Bddapron.Apronexpr.symbol ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t -> int
      val normalize_as_constraint :
        'a Bddapron.Apronexpr.t -> 'a Bddapron.Apronexpr.t
      val is_dependent_on_integer_only :
        ('a, [> Bddapron.Apronexpr.typ ]) Bddapron.Apronexpr.typ_of_var ->
        'a Bddapron.Apronexpr.t -> bool
      val typ_of_expr :
        ('a, [> Bddapron.Apronexpr.typ ]) Bddapron.Apronexpr.typ_of_var ->
        'a Bddapron.Apronexpr.t -> [ `Int | `Real ]
      val print :
        'a Bddapron.Apronexpr.symbol ->
        Format.formatter -> 'a Bddapron.Apronexpr.t -> unit
      val print_typ : Format.formatter -> [> Bddapron.Apronexpr.typ ] -> unit
      val of_linexpr0 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t -> Apron.Linexpr0.t -> 'a Bddapron.Apronexpr.t
      val of_linexpr1 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Linexpr1.t -> 'a Bddapron.Apronexpr.t
      val to_linexpr0 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t -> 'a Bddapron.Apronexpr.t -> Apron.Linexpr0.t
      val to_linexpr1 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t -> 'a Bddapron.Apronexpr.t -> Apron.Linexpr1.t
      val of_texpr0 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t -> Apron.Texpr0.t -> 'a Bddapron.Apronexpr.t
      val of_texpr1 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Texpr1.t -> 'a Bddapron.Apronexpr.t
      val to_texpr0 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t -> 'a Bddapron.Apronexpr.t -> Apron.Texpr0.t
      val to_texpr1 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t -> 'a Bddapron.Apronexpr.t -> Apron.Texpr1.t
      val to_apron0 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t ->
        'a Bddapron.Apronexpr.t ->
        [ `Lin of Apron.Linexpr0.t | `Tree of Apron.Texpr0.t ]
      val to_apron1 :
        'a Bddapron.Apronexpr.symbol ->
        Apron.Environment.t ->
        'a Bddapron.Apronexpr.t ->
        [ `Lin of Apron.Linexpr1.t | `Tree of Apron.Texpr1.t ]
      module Condition :
        sig
          type typ =
            Apron.Tcons1.typ =
              EQ
            | SUPEQ
            | SUP
            | DISEQ
            | EQMOD of Apron.Scalar.t
          type 'a t =
              Bddapron.Apronexpr.Condition.typ * 'a Bddapron.Apronexpr.expr
          val make :
            ('a, [> Bddapron.Apronexpr.Condition.typ ])
            Bddapron.Apronexpr.typ_of_var ->
            Bddapron.Apronexpr.Condition.typ ->
            'a Bddapron.Apronexpr.expr ->
            [ `Bool of bool | `Cond of 'a Bddapron.Apronexpr.Condition.t ]
          val negate :
            ('a, [> Bddapron.Apronexpr.Condition.typ ])
            Bddapron.Apronexpr.typ_of_var ->
            'a Bddapron.Apronexpr.Condition.t ->
            'a Bddapron.Apronexpr.Condition.t
          val support :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Condition.t -> 'a PSette.t
          val print :
            'a Bddapron.Apronexpr.symbol ->
            Format.formatter -> 'a Bddapron.Apronexpr.Condition.t -> unit
          val compare :
            'a Bddapron.Apronexpr.symbol ->
            'a Bddapron.Apronexpr.Condition.t ->
            'a Bddapron.Apronexpr.Condition.t -> int
          val of_lincons0 :
            'a Bddapron.Apronexpr.symbol ->
            ('a, [> Bddapron.Apronexpr.Condition.typ ])
            Bddapron.Apronexpr.typ_of_var ->
            Apron.Environment.t ->
            Apron.Lincons0.t ->
            [ `Bool of bool | `Cond of 'a Bddapron.Apronexpr.Condition.t ]
          val of_lincons1 :
            'a Bddapron.Apronexpr.symbol ->
            ('a, [> Bddapron.Apronexpr.Condition.typ ])
            Bddapron.Apronexpr.typ_of_var ->
            Apron.Lincons1.t ->
            [ `Bool of bool | `Cond of 'a Bddapron.Apronexpr.Condition.t ]
          val of_tcons0 :
            'a Bddapron.Apronexpr.symbol ->
            ('a, [> Bddapron.Apronexpr.Condition.typ ])
            Bddapron.Apronexpr.typ_of_var ->
            Apron.Environment.t ->
            Apron.Tcons0.t ->
            [ `Bool of bool | `Cond of 'a Bddapron.Apronexpr.Condition.t ]
          val of_tcons1 :
            'a Bddapron.Apronexpr.symbol ->
            ('a, [> Bddapron.Apronexpr.Condition.typ ])
            Bddapron.Apronexpr.typ_of_var ->
            Apron.Tcons1.t ->
            [ `Bool of bool | `Cond of 'a Bddapron.Apronexpr.Condition.t ]
          val to_tcons0 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Environment.t ->
            'a Bddapron.Apronexpr.Condition.t -> Apron.Tcons0.t
          val to_tcons1 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Environment.t ->
            'a Bddapron.Apronexpr.Condition.t -> Apron.Tcons1.t
          val to_apron0 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Environment.t ->
            'a Bddapron.Apronexpr.Condition.t ->
            [ `Lin of Apron.Lincons0.t | `Tree of Apron.Tcons0.t ]
          val to_apron1 :
            'a Bddapron.Apronexpr.symbol ->
            Apron.Environment.t ->
            'a Bddapron.Apronexpr.Condition.t ->
            [ `Lin of Apron.Lincons1.t | `Tree of Apron.Tcons1.t ]
        end
    end
  module Env :
    sig
      type 'a typdef = 'a Bdd.Env.typdef
      type 'a typ =
          [ `Benum of 'a | `Bint of bool * int | `Bool | `Int | `Real ]
      type 'a symbol =
        'a Bdd.Env.symbol = {
        compare : 'a -> 'a -> int;
        marshal : 'a -> string;
        unmarshal : string -> 'a;
        mutable print : Format.formatter -> 'a -> unit;
      }
      type ('a, 'b) ext = {
        mutable table : 'a Bddapron.Apronexpr.t Cudd.Mtbdd.table;
        mutable eapron : Apron.Environment.t;
        mutable aext : 'b;
      }
      type ('a, 'b, 'c, 'd) t0 =
          ('a, 'b, 'c, Cudd.Man.v, ('a, 'd) Bddapron.Env.ext) Bdd.Env.t0
      module O :
        sig
          type ('a, 'b, 'c, 'd) t = ('a, 'b, 'c, 'd) Bddapron.Env.t0
            constraint 'b = [> 'a Bddapron.Env.typ ]
            constraint 'c = [> 'a Bddapron.Env.typdef ]
          val make :
            symbol:'a Bddapron.Env.symbol ->
            copy_aext:('d -> 'd) ->
            ?bddindex0:int ->
            ?bddsize:int ->
            ?relational:bool ->
            Cudd.Man.vt ->
            'd ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
            Bddapron.Env.O.t
          val print :
            (Format.formatter -> ([> 'a Bddapron.Env.typ ] as 'b) -> unit) ->
            (Format.formatter -> ([> 'a Bddapron.Env.typdef ] as 'c) -> unit) ->
            (Format.formatter -> 'd -> unit) ->
            Format.formatter -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t -> unit
        end
      type 'a t =
          ('a, 'a Bddapron.Env.typ, 'a Bddapron.Env.typdef, unit)
          Bddapron.Env.O.t
      val print_typ :
        (Format.formatter -> 'a -> unit) ->
        Format.formatter -> [> 'a Bddapron.Env.typ ] -> unit
      val print_typdef :
        (Format.formatter -> 'a -> unit) ->
        Format.formatter -> [> 'a Bddapron.Env.typdef ] -> unit
      val print_idcondb :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> Format.formatter -> int * bool -> unit
      val print_order :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> Format.formatter -> unit
      val print :
        Format.formatter ->
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> unit
      val marshal : 'a -> string
      val unmarshal : string -> 'a
      val make_symbol :
        ?compare:('a -> 'a -> int) ->
        ?marshal:('a -> string) ->
        ?unmarshal:(string -> 'a) ->
        (Format.formatter -> 'a -> unit) -> 'a Bddapron.Env.symbol
      val string_symbol : string Bddapron.Env.symbol
      val make :
        symbol:'a Bddapron.Env.symbol ->
        ?bddindex0:int ->
        ?bddsize:int -> ?relational:bool -> Cudd.Man.vt -> 'a Bddapron.Env.t
      val make_string :
        ?bddindex0:int ->
        ?bddsize:int ->
        ?relational:bool -> Cudd.Man.vt -> string Bddapron.Env.t
      val copy :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
      val mem_typ :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a -> bool
      val mem_var :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a -> bool
      val mem_label :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a -> bool
      val typdef_of_typ :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ] as 'b, 'd)
        Bddapron.Env.O.t -> 'a -> 'b
      val typ_of_var :
        ('a, [> 'a Bddapron.Env.typ ] as 'b, [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a -> 'b
      val vars :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a PSette.t
      val labels :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a PSette.t
      val apron :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> Apron.Environment.t
      val add_typ_with :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ] as 'b, 'd)
        Bddapron.Env.O.t -> 'a -> 'b -> unit
      val add_vars_with :
        ('a, [> 'a Bddapron.Env.typ ] as 'b, [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> ('a * 'b) list -> int array option
      val remove_vars_with :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a list -> int array option
      val rename_vars_with :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ('a * 'a) list -> int array option * Apron.Dim.perm option
      val add_typ :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t -> 'a -> 'c -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
      val add_vars :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a * 'b) list -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
      val remove_vars :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t -> 'a list -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
      val rename_vars :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a * 'a) list -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
      val is_leq :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t -> bool
      val is_eq :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t -> bool
      val lce :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
        ('a, 'b, 'c, 'd) Bddapron.Env.O.t
      type change = {
        cbdd : Cudd.Man.v Bdd.Env.change;
        capron : Apron.Dim.change2;
      }
      val compute_change :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a, 'b, 'c, 'd) Bddapron.Env.O.t -> Bddapron.Env.change
      type ('a, 'b) value = ('a, 'b) Bdd.Env.value = { env : 'a; val0 : 'b; }
      val make_value :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        'e -> (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'e) Bddapron.Env.value
      val get_env : ('a, 'b) Bddapron.Env.value -> 'a
      val get_val0 : ('a, 'b) Bddapron.Env.value -> 'b
      val check_var :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a -> unit
      val check_lvar :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a list -> unit
      val check_value :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'e) Bddapron.Env.value -> unit
      val check_value2 :
        (('a, [> 'a Bddapron.Env.typ ] as 'b,
          [> 'a Bddapron.Env.typdef ] as 'c, 'd)
         Bddapron.Env.O.t, 'e)
        Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'f) Bddapron.Env.value -> unit
      val check_value3 :
        (('a, [> 'a Bddapron.Env.typ ] as 'b,
          [> 'a Bddapron.Env.typdef ] as 'c, 'd)
         Bddapron.Env.O.t, 'e)
        Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'f) Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'g) Bddapron.Env.value -> unit
      val check_lvarvalue :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a * (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'e) Bddapron.Env.value)
        list -> ('a * 'e) list
      val check_lvalue :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'e) Bddapron.Env.value list ->
        'e list
      val check_ovalue :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'e) Bddapron.Env.value option ->
        'e option
      val mapunop :
        ('e -> 'f) ->
        (('a, [> 'a Bddapron.Env.typ ] as 'b,
          [> 'a Bddapron.Env.typdef ] as 'c, 'd)
         Bddapron.Env.O.t, 'e)
        Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'f) Bddapron.Env.value
      val mapbinop :
        ('e -> 'f -> 'g) ->
        (('a, [> 'a Bddapron.Env.typ ] as 'b,
          [> 'a Bddapron.Env.typdef ] as 'c, 'd)
         Bddapron.Env.O.t, 'e)
        Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'f) Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'g) Bddapron.Env.value
      val mapbinope :
        (('a, [> 'a Bddapron.Env.typ ] as 'b,
          [> 'a Bddapron.Env.typdef ] as 'c, 'd)
         Bddapron.Env.O.t -> 'e -> 'f -> 'g) ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'e) Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'f) Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'g) Bddapron.Env.value
      val mapterop :
        ('e -> 'f -> 'g -> 'h) ->
        (('a, [> 'a Bddapron.Env.typ ] as 'b,
          [> 'a Bddapron.Env.typdef ] as 'c, 'd)
         Bddapron.Env.O.t, 'e)
        Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'f) Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'g) Bddapron.Env.value ->
        (('a, 'b, 'c, 'd) Bddapron.Env.O.t, 'h) Bddapron.Env.value
      val var_of_aprondim :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> Apron.Dim.t -> 'a
      val aprondim_of_var :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a -> Apron.Dim.t
      val string_of_aprondim :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> Apron.Dim.t -> string
    end
  module Cond :
    sig
      type 'a cond = [ `Apron of 'a Bddapron.Apronexpr.Condition.t ]
      val print_cond :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        Format.formatter -> [< 'a Bddapron.Cond.cond ] -> unit
      val compare_cond :
        'a Bdd.Env.symbol ->
        [< 'a Bddapron.Cond.cond ] -> [< 'a Bddapron.Cond.cond ] -> int
      val negate_cond :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a Bddapron.Cond.cond -> 'a Bddapron.Cond.cond
      val support_cond :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> [< 'a Bddapron.Cond.cond ] -> 'a PSette.t
      module O :
        sig
          type ('a, 'b) t =
              ('a, 'b, 'a Bddapron.Cond.cond, Cudd.Man.v) Bdd.Cond.t
            constraint 'b =
              ('a, [> 'a Bddapron.Env.typ ] as 'c,
               [> 'a Bddapron.Env.typdef ] as 'd, 'e)
              Bddapron.Env.O.t
          val make :
            symbol:'a Bdd.Env.symbol ->
            ?bddindex0:int ->
            ?bddsize:int ->
            Cudd.Man.vt ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'b)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t
        end
      type 'a t = ('a, 'a Bddapron.Env.t) Bddapron.Cond.O.t
      val make :
        symbol:'a Bdd.Env.symbol ->
        ?bddindex0:int -> ?bddsize:int -> Cudd.Man.vt -> 'a Bddapron.Cond.t
      val copy : 'a Bddapron.Cond.t -> 'a Bddapron.Cond.t
      val print :
        'a Bddapron.Env.t -> Format.formatter -> 'a Bddapron.Cond.t -> unit
      type ('a, 'b) value =
        ('a, 'b) Bdd.Cond.value = {
        cond : 'a;
        val1 : 'b;
      }
      val make_value : 'a -> 'b -> ('a, 'b) Bddapron.Cond.value
      val get_cond : ('a, 'b) Bddapron.Cond.value -> 'a
      val get_val1 : ('a, 'b) Bddapron.Cond.value -> 'b
      val get_env :
        ('a, ('b, 'c) Bddapron.Env.value) Bddapron.Cond.value -> 'b
      val get_val0 :
        ('a, ('b, 'c) Bddapron.Env.value) Bddapron.Cond.value -> 'c
    end
  module ApronexprDD :
    sig
      type 'a t = 'a Bddapron.Apronexpr.t Cudd.Mtbdd.t
      val of_expr :
        [> `Apron of 'a Bddapron.ApronexprDD.t ] -> 'a Bddapron.ApronexprDD.t
      val to_expr :
        'a Bddapron.ApronexprDD.t -> [> `Apron of 'a Bddapron.ApronexprDD.t ]
      val of_apronexpr :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Apronexpr.t -> 'a Bddapron.ApronexprDD.t
      val print :
        (Format.formatter -> Cudd.Bdd.vt -> unit) ->
        'a Bddapron.Apronexpr.symbol ->
        Format.formatter -> 'a Bddapron.ApronexprDD.t -> unit
      val is_zero :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a Bddapron.Apronexpr.t -> bool
      val is_one :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a Bddapron.Apronexpr.t -> bool
      val absorbant_zero :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Apronexpr.t Cudd.Mtbdd.unique ->
        'a Bddapron.Apronexpr.t Cudd.Mtbdd.unique option
      val absorbant_one :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Apronexpr.t Cudd.Mtbdd.unique ->
        'a Bddapron.Apronexpr.t Cudd.Mtbdd.unique option
      val cst :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> Apron.Coeff.t -> 'a Bddapron.ApronexprDD.t
      val var :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a -> 'a Bddapron.ApronexprDD.t
      val add :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.ApronexprDD.t ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val sub :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.ApronexprDD.t ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val mul :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.ApronexprDD.t ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val div :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.ApronexprDD.t ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val gmod :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.ApronexprDD.t ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val negate :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val cast :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val sqrt :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        ?typ:Apron.Texpr1.typ ->
        ?round:Apron.Texpr1.round ->
        'a Bddapron.ApronexprDD.t -> 'a Bddapron.ApronexprDD.t
      val support_leaf :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a Bddapron.ApronexprDD.t -> 'a PSette.t
      val support_cond :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t -> 'a Bddapron.ApronexprDD.t -> Cudd.Bdd.vt
      val substitute_linexpr :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Apronexpr.Lin.t ->
        ('a, [> `Apron of 'a Bddapron.ApronexprDD.t ]) PMappe.t ->
        'a Bddapron.ApronexprDD.t
      val substitute_polyexpr :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Apronexpr.Poly.t ->
        ('a, [> `Apron of 'a Bddapron.ApronexprDD.t ]) PMappe.t ->
        'a Bddapron.ApronexprDD.t
      val substitute_treeexpr :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Apronexpr.Tree.t ->
        ('a, [> `Apron of 'a Bddapron.ApronexprDD.t ]) PMappe.t ->
        'a Bddapron.ApronexprDD.t
      val substitute :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Apronexpr.t ->
        ('a, [> `Apron of 'a Bddapron.ApronexprDD.t ]) PMappe.t ->
        'a Bddapron.ApronexprDD.t
      module Condition :
        sig
          val of_apronexpr :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Apronexpr.Condition.t -> Cudd.Bdd.vt
          val of_condition :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            [< `Bool of bool | `Cond of 'a Bddapron.Apronexpr.Condition.t ] ->
            Cudd.Bdd.vt
          val make :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            Bddapron.Apronexpr.Condition.typ ->
            'a Bddapron.ApronexprDD.t -> Cudd.Bdd.vt
          val supeq :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.ApronexprDD.t -> Cudd.Bdd.vt
          val sup :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.ApronexprDD.t -> Cudd.Bdd.vt
          val eq :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.ApronexprDD.t -> Cudd.Bdd.vt
          val substitute :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Apronexpr.Condition.t ->
            ('a, [> `Apron of 'a Bddapron.ApronexprDD.t ]) PMappe.t ->
            Cudd.Bdd.vt
        end
    end
  module Common :
    sig
      val tcons0_array_of_cubecond :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
        Cudd.Bdd.vt -> Apron.Tcons0.t array
      val lvar_split :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
        Bddapron.Env.O.t ->
        'a list -> Cudd.Man.v Cudd.Bdd.t * Apron.Dim.t array
      val condition_of_tcons0 :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        Apron.Tcons0.t ->
        [ `Bool of bool | `Cond of 'a Bddapron.Apronexpr.Condition.t ]
      val bdd_of_tcons0 :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
        Apron.Tcons0.t -> Cudd.Bdd.vt
      val bdd_of_tcons0_array :
        ('a, [> 'a Bddapron.Env.typ ] as 'b,
         [> 'a Bddapron.Env.typdef ] as 'c, 'd)
        Bddapron.Env.O.t ->
        ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
        Apron.Tcons0.t array -> Cudd.Bdd.vt
    end
  module ApronDD :
    sig
      type 'a leaf = 'a Apron.Abstract0.t
      type 'a t = 'a Bddapron.ApronDD.leaf Cudd.Mtbddc.t
      type 'a table = 'a Bddapron.ApronDD.leaf Cudd.Mtbddc.table
      type 'a leaf_u = 'a Bddapron.ApronDD.leaf Cudd.Mtbddc.unique
      type 'a global = {
        op_is_leq :
          ('a Bddapron.ApronDD.leaf_u, 'a Bddapron.ApronDD.leaf_u)
          Cudd.User.test2;
        op_join :
          ('a Bddapron.ApronDD.leaf_u, 'a Bddapron.ApronDD.leaf_u,
           'a Bddapron.ApronDD.leaf_u)
          Cudd.User.op2;
        op_meet :
          ('a Bddapron.ApronDD.leaf_u, 'a Bddapron.ApronDD.leaf_u,
           'a Bddapron.ApronDD.leaf_u)
          Cudd.User.op2;
        op_exist : 'a Bddapron.ApronDD.leaf_u Cudd.User.exist;
      }
      type 'a man = {
        apron : 'a Apron.Manager.t;
        table : 'a Bddapron.ApronDD.table;
        oglobal : 'a Bddapron.ApronDD.global option;
      }
      val make_table : 'a Apron.Manager.t -> 'a Bddapron.ApronDD.table
      val neutral_join : 'a Apron.Abstract0.t -> bool
      val special_is_leq :
        'a Apron.Manager.t ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t -> bool option
      val special_join :
        'a Apron.Manager.t ->
        'a Bddapron.ApronDD.t ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t option
      val special_meet :
        'a Apron.Manager.t ->
        'a Bddapron.ApronDD.t ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t option
      val make_global :
        'a Apron.Manager.t ->
        'a Bddapron.ApronDD.table -> 'a Bddapron.ApronDD.global
      val make_man :
        ?global:bool -> 'a Apron.Manager.t -> 'a Bddapron.ApronDD.man
      val make_op_join :
        'a Bddapron.ApronDD.man ->
        ('a Bddapron.ApronDD.leaf_u, 'a Bddapron.ApronDD.leaf_u,
         'a Bddapron.ApronDD.leaf_u)
        Cudd.User.op2
      val print :
        ?print_apron:((int -> string) ->
                      Format.formatter -> 'a Apron.Abstract0.t -> unit) ->
        (Format.formatter -> Cudd.Bdd.vt -> unit) ->
        (int -> string) -> Format.formatter -> 'a Bddapron.ApronDD.t -> unit
      val cst :
        cudd:Cudd.Man.vt ->
        'a Bddapron.ApronDD.man ->
        'a Apron.Abstract0.t -> 'a Bddapron.ApronDD.t
      val bottom :
        cudd:Cudd.Man.vt ->
        'a Bddapron.ApronDD.man ->
        Apron.Dim.dimension -> 'a Bddapron.ApronDD.t
      val top :
        cudd:Cudd.Man.vt ->
        'a Bddapron.ApronDD.man ->
        Apron.Dim.dimension -> 'a Bddapron.ApronDD.t
      val is_bottom :
        'a Bddapron.ApronDD.man -> 'a Bddapron.ApronDD.t -> bool
      val is_top : 'a Bddapron.ApronDD.man -> 'a Bddapron.ApronDD.t -> bool
      val is_eq :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t -> bool
      val is_leq :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t -> bool
      val join :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t
      val meet :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t
      val widening :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t ->
        'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t
      val widening_threshold :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t ->
        'a Bddapron.ApronDD.t ->
        Apron.Lincons0.t array -> 'a Bddapron.ApronDD.t
      val meet_tcons_array :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t ->
        Apron.Tcons0.t array -> 'a Bddapron.ApronDD.t
      val forget_array :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t -> Apron.Dim.t array -> 'a Bddapron.ApronDD.t
      val permute_dimensions :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t -> Apron.Dim.perm -> 'a Bddapron.ApronDD.t
      val add_dimensions :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t ->
        Apron.Dim.change -> bool -> 'a Bddapron.ApronDD.t
      val remove_dimensions :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t -> Apron.Dim.change -> 'a Bddapron.ApronDD.t
      val apply_dimchange2 :
        'a Bddapron.ApronDD.man ->
        'a Bddapron.ApronDD.t ->
        Apron.Dim.change2 -> bool -> 'a Bddapron.ApronDD.t
      type asssub = Assign | Substitute
      val asssub_texpr_array :
        ?asssub_bdd:(Cudd.Bdd.vt -> Cudd.Bdd.vt) ->
        Bddapron.ApronDD.asssub ->
        'b Bdd.Env.symbol ->
        'a Bddapron.ApronDD.man ->
        Apron.Environment.t ->
        'a Bddapron.ApronDD.t ->
        Apron.Dim.t array ->
        'b Bddapron.ApronexprDD.t array ->
        'a Bddapron.ApronDD.t option -> 'a Bddapron.ApronDD.t
      val assign_texpr_array :
        'b Bdd.Env.symbol ->
        'a Bddapron.ApronDD.man ->
        Apron.Environment.t ->
        'a Bddapron.ApronDD.t ->
        Apron.Dim.t array ->
        'b Bddapron.ApronexprDD.t array ->
        'a Bddapron.ApronDD.t option -> 'a Bddapron.ApronDD.t
      val substitute_texpr_array :
        'b Bdd.Env.symbol ->
        'a Bddapron.ApronDD.man ->
        Apron.Environment.t ->
        'a Bddapron.ApronDD.t ->
        Apron.Dim.t array ->
        'b Bddapron.ApronexprDD.t array ->
        'a Bddapron.ApronDD.t option -> 'a Bddapron.ApronDD.t
      val exist :
        'a Bddapron.ApronDD.man ->
        supp:Cudd.Bdd.vt -> 'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t
      val existand :
        'a Bddapron.ApronDD.man ->
        bottom:'a Apron.Abstract0.t Cudd.Mtbddc.unique ->
        supp:Cudd.Bdd.vt ->
        Cudd.Bdd.vt -> 'a Bddapron.ApronDD.t -> 'a Bddapron.ApronDD.t
    end
  module Expr0 :
    sig
      type 'a t =
          [ `Apron of 'a Bddapron.ApronexprDD.t
          | `Benum of Cudd.Man.v Bdd.Enum.t
          | `Bint of Cudd.Man.v Bdd.Int.t
          | `Bool of Cudd.Man.v Cudd.Bdd.t ]
      type 'a expr = 'a Bddapron.Expr0.t
      module Bool :
        sig
          type 'a t = Cudd.Bdd.vt
          val of_expr : 'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.Bool.t
          val to_expr : 'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.expr
          val dtrue :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a Bddapron.Expr0.Bool.t
          val dfalse :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a Bddapron.Expr0.Bool.t
          val of_bool :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> bool -> 'a Bddapron.Expr0.Bool.t
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr0.Bool.t
          val ite :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val dnot :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val dand :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val dor :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val xor :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val nand :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val nor :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val nxor :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val leq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val eq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val is_true :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a Bddapron.Expr0.Bool.t -> bool
          val is_false :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a Bddapron.Expr0.Bool.t -> bool
          val is_cst :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a Bddapron.Expr0.Bool.t -> bool
          val is_leq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t -> bool
          val is_eq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t -> bool
          val is_and_false :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t -> bool
          val exist :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a list -> 'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val forall :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a list -> 'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val cofactor :
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val restrict :
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val tdrestrict :
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val permute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Expr0.Bool.t -> int array -> 'a Bddapron.Expr0.Bool.t
          val varmap : 'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            ('a * 'a) list -> 'a Bddapron.Expr0.Bool.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            ('a * 'a Bddapron.Expr0.expr) list -> 'a Bddapron.Expr0.Bool.t
          val print :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr0.Bool.t -> unit
        end
      module Bint :
        sig
          type 'a t = Cudd.Man.v Bdd.Int.t
          val of_expr : 'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.Bint.t
          val to_expr : 'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.expr
          val of_int :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            [ `Bint of bool * int ] -> int -> 'a Bddapron.Expr0.Bint.t
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr0.Bint.t
          val ite :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val neg :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val succ :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val pred :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val add :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val sub :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val mul :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val shift_left :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            int -> 'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val shift_right :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            int -> 'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val scale :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            int -> 'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val zero :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bool.t
          val eq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bool.t
          val eq_int :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t -> int -> 'a Bddapron.Expr0.Bool.t
          val supeq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bool.t
          val supeq_int :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t -> int -> 'a Bddapron.Expr0.Bool.t
          val sup :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bool.t
          val sup_int :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t -> int -> 'a Bddapron.Expr0.Bool.t
          val cofactor :
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bint.t
          val restrict :
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bint.t
          val tdrestrict :
            'a Bddapron.Expr0.Bint.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Bint.t
          val permute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Expr0.Bint.t -> int array -> 'a Bddapron.Expr0.Bint.t
          val varmap : 'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            ('a * 'a) list -> 'a Bddapron.Expr0.Bint.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bint.t ->
            ('a * 'a Bddapron.Expr0.expr) list -> 'a Bddapron.Expr0.Bint.t
          val print :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr0.Bint.t -> unit
        end
      module Benum :
        sig
          type 'a t = Cudd.Man.v Bdd.Enum.t
          val of_expr : 'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.Benum.t
          val to_expr : 'a Bddapron.Expr0.Benum.t -> 'a Bddapron.Expr0.expr
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr0.Benum.t
          val ite :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Benum.t ->
            'a Bddapron.Expr0.Benum.t -> 'a Bddapron.Expr0.Benum.t
          val eq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Benum.t ->
            'a Bddapron.Expr0.Benum.t -> 'a Bddapron.Expr0.Bool.t
          val eq_label :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Benum.t -> 'a -> 'a Bddapron.Expr0.Bool.t
          val cofactor :
            'a Bddapron.Expr0.Benum.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Benum.t
          val restrict :
            'a Bddapron.Expr0.Benum.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Benum.t
          val tdrestrict :
            'a Bddapron.Expr0.Benum.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Benum.t
          val permute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Expr0.Benum.t ->
            int array -> 'a Bddapron.Expr0.Benum.t
          val varmap : 'a Bddapron.Expr0.Benum.t -> 'a Bddapron.Expr0.Benum.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Benum.t ->
            ('a * 'a) list -> 'a Bddapron.Expr0.Benum.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Benum.t ->
            ('a * 'a Bddapron.Expr0.expr) list -> 'a Bddapron.Expr0.Benum.t
          val print :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr0.Benum.t -> unit
        end
      type apron_coeff = Apron.Coeff.t
      type apron_typ = Apron.Texpr1.typ
      type apron_round = Apron.Texpr1.round
      module Apron :
        sig
          type 'a t = 'a Bddapron.ApronexprDD.t
          val of_expr : 'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.Apron.t
          val to_expr : 'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.expr
          val cst :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> Apron.Coeff.t -> 'a Bddapron.Expr0.Apron.t
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr0.Apron.t
          val add :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val sub :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val mul :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val div :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val gmod :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val negate :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val cast :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val sqrt :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val supeq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Bool.t
          val sup :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Bool.t
          val eq :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Bool.t
          val ite :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t ->
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val cofactor :
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Apron.t
          val restrict :
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Apron.t
          val tdrestrict :
            'a Bddapron.Expr0.Apron.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.Apron.t
          val permute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Expr0.Apron.t ->
            int array -> 'a Bddapron.Expr0.Apron.t
          val varmap : 'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Apron.t ->
            ('a * 'a) list -> 'a Bddapron.Expr0.Apron.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Apron.t ->
            ('a * 'a Bddapron.Expr0.expr) list -> 'a Bddapron.Expr0.Apron.t
          val print :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr0.Apron.t -> unit
        end
      val typ_of_expr :
        'a Bddapron.Env.t -> 'a Bddapron.Expr0.t -> 'a Bddapron.Env.typ
      val var :
        'a Bddapron.Env.t -> 'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr0.t
      val ite :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr0.Bool.t ->
        'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t
      val cofactor :
        'a Bddapron.Expr0.t ->
        'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.t
      val substitute_by_var :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr0.t -> ('a * 'a) list -> 'a Bddapron.Expr0.t
      val substitute_by_var_list :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr0.t list ->
        ('a * 'a) list -> 'a Bddapron.Expr0.t list
      val substitute :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr0.t ->
        ('a * 'a Bddapron.Expr0.t) list -> 'a Bddapron.Expr0.t
      val substitute_list :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr0.t list ->
        ('a * 'a Bddapron.Expr0.t) list -> 'a Bddapron.Expr0.t list
      val restrict :
        'a Bddapron.Expr0.t ->
        'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.t
      val tdrestrict :
        'a Bddapron.Expr0.t ->
        'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr0.t
      val permute :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Expr0.t -> int array -> 'a Bddapron.Expr0.t
      val varmap : 'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t
      val support :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t -> 'a Bddapron.Expr0.t -> 'a PSette.t
      val eq :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr0.t ->
        'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.Bool.t
      val support_cond : Cudd.Man.vt -> 'a Bddapron.Expr0.t -> Cudd.Bdd.vt
      val print :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        Format.formatter -> [< 'a Bddapron.Expr0.t ] -> unit
      val normalize :
        ?reduce:bool ->
        ?careset:bool ->
        'a Bddapron.Cond.t * 'a Bddapron.Expr0.t list ->
        'a Bddapron.Cond.t * 'a Bddapron.Expr0.t list
      module O :
        sig
          val check_typ2 :
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
            Bddapron.Env.O.t ->
            [< 'a Bddapron.Expr0.t ] ->
            [< 'a Bddapron.Expr0.t ] -> 'a Bddapron.Env.typ
          module Bool :
            sig
              type 'a t = Cudd.Bdd.vt
              val of_expr :
                'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.O.Bool.t
              val to_expr :
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.expr
              val dtrue :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t
              val dfalse :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t
              val of_bool :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                bool -> 'a Bddapron.Expr0.O.Bool.t
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a -> 'a Bddapron.Expr0.O.Bool.t
              val ite :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val dnot :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val dand :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val dor :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val xor :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val nand :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val nor :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val nxor :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val leq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val eq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val is_true :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t -> bool
              val is_false :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t -> bool
              val is_cst :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t -> bool
              val is_leq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> bool
              val is_eq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> bool
              val is_and_false :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> bool
              val exist :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a list ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val forall :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a list ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val cofactor :
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val restrict :
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val tdrestrict :
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val permute :
                ?memo:Cudd.Memo.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                int array -> 'a Bddapron.Expr0.O.Bool.t
              val varmap :
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bool.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                ('a * 'a) list -> 'a Bddapron.Expr0.O.Bool.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                ('a * 'a Bddapron.Expr0.expr) list ->
                'a Bddapron.Expr0.O.Bool.t
              val print :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                Format.formatter -> 'a Bddapron.Expr0.O.Bool.t -> unit
            end
          module Bint :
            sig
              type 'a t = Cudd.Man.v Bdd.Int.t
              val of_expr :
                'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.O.Bint.t
              val to_expr :
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.expr
              val of_int :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                [> `Bint of bool * int ] -> int -> 'a Bddapron.Expr0.O.Bint.t
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a -> 'a Bddapron.Expr0.O.Bint.t
              val ite :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val neg :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val succ :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val pred :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val add :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val sub :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val mul :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val shift_left :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                int ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val shift_right :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                int ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val scale :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                int ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val zero :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bool.t
              val eq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bool.t
              val eq_int :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                int -> 'a Bddapron.Expr0.O.Bool.t
              val supeq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bool.t
              val supeq_int :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                int -> 'a Bddapron.Expr0.O.Bool.t
              val sup :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bool.t
              val sup_int :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                int -> 'a Bddapron.Expr0.O.Bool.t
              val cofactor :
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bint.t
              val restrict :
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bint.t
              val tdrestrict :
                'a Bddapron.Expr0.O.Bint.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Bint.t
              val permute :
                ?memo:Cudd.Memo.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                int array -> 'a Bddapron.Expr0.O.Bint.t
              val varmap :
                'a Bddapron.Expr0.O.Bint.t -> 'a Bddapron.Expr0.O.Bint.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                ('a * 'a) list -> 'a Bddapron.Expr0.O.Bint.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bint.t ->
                ('a * 'a Bddapron.Expr0.expr) list ->
                'a Bddapron.Expr0.O.Bint.t
              val print :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                Format.formatter -> 'a Bddapron.Expr0.O.Bint.t -> unit
            end
          module Benum :
            sig
              type 'a t = Cudd.Man.v Bdd.Enum.t
              val of_expr :
                'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.O.Benum.t
              val to_expr :
                'a Bddapron.Expr0.O.Benum.t -> 'a Bddapron.Expr0.expr
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a -> 'a Bddapron.Expr0.O.Benum.t
              val ite :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Benum.t ->
                'a Bddapron.Expr0.O.Benum.t -> 'a Bddapron.Expr0.O.Benum.t
              val eq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Benum.t ->
                'a Bddapron.Expr0.O.Benum.t -> 'a Bddapron.Expr0.O.Bool.t
              val eq_label :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Benum.t ->
                'a -> 'a Bddapron.Expr0.O.Bool.t
              val cofactor :
                'a Bddapron.Expr0.O.Benum.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Benum.t
              val restrict :
                'a Bddapron.Expr0.O.Benum.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Benum.t
              val tdrestrict :
                'a Bddapron.Expr0.O.Benum.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Benum.t
              val permute :
                ?memo:Cudd.Memo.t ->
                'a Bddapron.Expr0.O.Benum.t ->
                int array -> 'a Bddapron.Expr0.O.Benum.t
              val varmap :
                'a Bddapron.Expr0.O.Benum.t -> 'a Bddapron.Expr0.O.Benum.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Benum.t ->
                ('a * 'a) list -> 'a Bddapron.Expr0.O.Benum.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Benum.t ->
                ('a * 'a Bddapron.Expr0.expr) list ->
                'a Bddapron.Expr0.O.Benum.t
              val print :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                Format.formatter -> 'a Bddapron.Expr0.O.Benum.t -> unit
            end
          module Apron :
            sig
              type 'a t = 'a Bddapron.ApronexprDD.t
              val of_expr :
                [> `Apron of 'a Bddapron.Expr0.O.Apron.t ] ->
                'a Bddapron.Expr0.O.Apron.t
              val to_expr :
                'a Bddapron.Expr0.O.Apron.t ->
                [> `Apron of 'a Bddapron.Expr0.O.Apron.t ]
              val cst :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                Bddapron.Expr0.apron_coeff -> 'a Bddapron.Expr0.O.Apron.t
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a -> 'a Bddapron.Expr0.O.Apron.t
              val add :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr0.apron_typ ->
                ?round:Bddapron.Expr0.apron_round ->
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val sub :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr0.apron_typ ->
                ?round:Bddapron.Expr0.apron_round ->
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val mul :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr0.apron_typ ->
                ?round:Bddapron.Expr0.apron_round ->
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val div :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr0.apron_typ ->
                ?round:Bddapron.Expr0.apron_round ->
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val gmod :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr0.apron_typ ->
                ?round:Bddapron.Expr0.apron_round ->
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val negate :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val cast :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr0.apron_typ ->
                ?round:Bddapron.Expr0.apron_round ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val sqrt :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr0.apron_typ ->
                ?round:Bddapron.Expr0.apron_round ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val supeq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Bool.t
              val sup :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Bool.t
              val eq :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Bool.t
              val ite :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Bool.t ->
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val cofactor :
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Apron.t
              val restrict :
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Apron.t
              val tdrestrict :
                'a Bddapron.Expr0.O.Apron.t ->
                'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.O.Apron.t
              val permute :
                ?memo:Cudd.Memo.t ->
                'a Bddapron.Expr0.O.Apron.t ->
                int array -> 'a Bddapron.Expr0.O.Apron.t
              val varmap :
                'a Bddapron.Expr0.O.Apron.t -> 'a Bddapron.Expr0.O.Apron.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Apron.t ->
                ('a * 'a) list -> 'a Bddapron.Expr0.O.Apron.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.O.Apron.t ->
                ('a * 'a Bddapron.Expr0.expr) list ->
                'a Bddapron.Expr0.O.Apron.t
              val print :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                Format.formatter -> 'a Bddapron.Expr0.O.Apron.t -> unit
            end
          val typ_of_expr :
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
            Bddapron.Env.O.t ->
            [< 'a Bddapron.Expr0.t ] -> 'a Bddapron.Env.typ
          val var :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a -> 'a Bddapron.Expr0.t
          val ite :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.O.Bool.t ->
            'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t
          val cofactor :
            'a Bddapron.Expr0.t ->
            'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.t
          val restrict :
            'a Bddapron.Expr0.t ->
            'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.t
          val tdrestrict :
            'a Bddapron.Expr0.t ->
            'a Bddapron.Expr0.O.Bool.t -> 'a Bddapron.Expr0.t
          val permute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Expr0.t -> int array -> 'a Bddapron.Expr0.t
          val permute_list :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Expr0.t list -> int array -> 'a Bddapron.Expr0.t list
          val varmap : 'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.t -> ('a * 'a) list -> 'a Bddapron.Expr0.t
          val substitute_by_var_list :
            ?memo:Cudd.Memo.t ->
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.t list ->
            ('a * 'a) list -> 'a Bddapron.Expr0.t list
          val substitute :
            ?memo:Cudd.Memo.t ->
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.t ->
            ('a * 'a Bddapron.Expr0.t) list -> 'a Bddapron.Expr0.t
          val substitute_list :
            ?memo:Cudd.Memo.t ->
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.t list ->
            ('a * 'a Bddapron.Expr0.t) list -> 'a Bddapron.Expr0.t list
          val support :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.t -> 'a PSette.t
          val eq :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.t ->
            'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.O.Bool.t
          val support_cond :
            Cudd.Man.vt -> 'a Bddapron.Expr0.t -> Cudd.Bdd.vt
          val print :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            Format.formatter -> [< 'a Bddapron.Expr0.t ] -> unit
          val print_bdd :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            Format.formatter -> Cudd.Bdd.vt -> unit
          val normalize :
            ?reduce:bool ->
            ?careset:bool ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t * 'a Bddapron.Expr0.t list ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t *
            'a Bddapron.Expr0.t list
          val compose_of_lvarexpr :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            ('a * 'a Bddapron.Expr0.t) list ->
            Cudd.Bdd.vt array option * ('a, 'a Bddapron.Expr0.t) PMappe.t
        end
    end
  module Expr1 :
    sig
      type 'a t = ('a Bddapron.Env.t, 'a Bddapron.Expr0.t) Bddapron.Env.value
      type 'a expr = 'a Bddapron.Expr1.t
      module Bool :
        sig
          type 'a t =
              ('a Bddapron.Env.t, Cudd.Man.v Bddapron.Expr0.Bool.t)
              Bddapron.Env.value
          val of_expr0 :
            'a Bddapron.Env.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val get_env : 'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Env.t
          val to_expr0 : 'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val of_expr : 'a Bddapron.Expr1.expr -> 'a Bddapron.Expr1.Bool.t
          val to_expr : 'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.expr
          val extend_environment :
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Env.t -> 'a Bddapron.Expr1.Bool.t
          val dtrue :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a Bddapron.Expr1.Bool.t
          val dfalse :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a Bddapron.Expr1.Bool.t
          val of_bool :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> bool -> 'a Bddapron.Expr1.Bool.t
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr1.Bool.t
          val dnot :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val dand :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val dor :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val xor :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val nand :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val nor :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val nxor :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val eq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val leq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val ite :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val is_true :
            'a Bddapron.Cond.t -> 'a Bddapron.Expr1.Bool.t -> bool
          val is_false :
            'a Bddapron.Cond.t -> 'a Bddapron.Expr1.Bool.t -> bool
          val is_cst : 'a Bddapron.Cond.t -> 'a Bddapron.Expr1.Bool.t -> bool
          val is_eq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t -> bool
          val is_leq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t -> bool
          val is_inter_false :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t -> bool
          val exist :
            'a Bddapron.Cond.t ->
            'a list -> 'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val forall :
            'a Bddapron.Cond.t ->
            'a list -> 'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val cofactor :
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val restrict :
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val tdrestrict :
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            ('a * 'a) list -> 'a Bddapron.Expr1.Bool.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            ('a * 'a Bddapron.Expr1.expr) list -> 'a Bddapron.Expr1.Bool.t
          val print :
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr1.Bool.t -> unit
        end
      module Bint :
        sig
          type 'a t =
              ('a Bddapron.Env.t, Cudd.Man.v Bdd.Int.t) Bddapron.Env.value
          val of_expr0 :
            'a Bddapron.Env.t ->
            'a Bddapron.Expr0.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val get_env : 'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Env.t
          val to_expr0 : 'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr0.Bint.t
          val of_expr : 'a Bddapron.Expr1.expr -> 'a Bddapron.Expr1.Bint.t
          val to_expr : 'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.expr
          val extend_environment :
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Env.t -> 'a Bddapron.Expr1.Bint.t
          val of_int :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            [ `Bint of bool * int ] -> int -> 'a Bddapron.Expr1.Bint.t
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr1.Bint.t
          val neg :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val succ :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val pred :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val add :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val sub :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val mul :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val shift_left :
            'a Bddapron.Cond.t ->
            int -> 'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val shift_right :
            'a Bddapron.Cond.t ->
            int -> 'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val scale :
            'a Bddapron.Cond.t ->
            int -> 'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val ite :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bint.t
          val zero :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bool.t
          val eq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bool.t
          val supeq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bool.t
          val sup :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bint.t -> 'a Bddapron.Expr1.Bool.t
          val eq_int :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> int -> 'a Bddapron.Expr1.Bool.t
          val supeq_int :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> int -> 'a Bddapron.Expr1.Bool.t
          val sup_int :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> int -> 'a Bddapron.Expr1.Bool.t
          val cofactor :
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bint.t
          val restrict :
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bint.t
          val tdrestrict :
            'a Bddapron.Expr1.Bint.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Bint.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            ('a * 'a) list -> 'a Bddapron.Expr1.Bint.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t ->
            ('a * 'a Bddapron.Expr1.expr) list -> 'a Bddapron.Expr1.Bint.t
          val guard_of_int :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> int -> 'a Bddapron.Expr1.Bool.t
          val guardints :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bint.t -> ('a Bddapron.Expr1.Bool.t * int) list
          val print :
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr1.Bint.t -> unit
        end
      module Benum :
        sig
          type 'a t =
              ('a Bddapron.Env.t, Cudd.Man.v Bdd.Enum.t) Bddapron.Env.value
          val of_expr0 :
            'a Bddapron.Env.t ->
            'a Bddapron.Expr0.Benum.t -> 'a Bddapron.Expr1.Benum.t
          val get_env : 'a Bddapron.Expr1.Benum.t -> 'a Bddapron.Env.t
          val to_expr0 :
            'a Bddapron.Expr1.Benum.t -> 'a Bddapron.Expr0.Benum.t
          val of_expr : 'a Bddapron.Expr1.expr -> 'a Bddapron.Expr1.Benum.t
          val to_expr : 'a Bddapron.Expr1.Benum.t -> 'a Bddapron.Expr1.expr
          val extend_environment :
            'a Bddapron.Expr1.Benum.t ->
            'a Bddapron.Env.t -> 'a Bddapron.Expr1.Benum.t
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr1.Benum.t
          val ite :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Benum.t ->
            'a Bddapron.Expr1.Benum.t -> 'a Bddapron.Expr1.Benum.t
          val eq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Benum.t ->
            'a Bddapron.Expr1.Benum.t -> 'a Bddapron.Expr1.Bool.t
          val eq_label :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Benum.t -> 'a -> 'a Bddapron.Expr1.Bool.t
          val cofactor :
            'a Bddapron.Expr1.Benum.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Benum.t
          val restrict :
            'a Bddapron.Expr1.Benum.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Benum.t
          val tdrestrict :
            'a Bddapron.Expr1.Benum.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Benum.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Benum.t ->
            ('a * 'a) list -> 'a Bddapron.Expr1.Benum.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Benum.t ->
            ('a * 'a Bddapron.Expr1.expr) list -> 'a Bddapron.Expr1.Benum.t
          val guard_of_label :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Benum.t -> 'a -> 'a Bddapron.Expr1.Bool.t
          val guardlabels :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Benum.t -> ('a Bddapron.Expr1.Bool.t * 'a) list
          val print :
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr1.Benum.t -> unit
        end
      type apron_coeff = Apron.Coeff.t
      type apron_typ = Apron.Texpr1.typ
      type apron_round = Apron.Texpr1.round
      type apron_cons_typ = Apron.Tcons1.typ
      module Apron :
        sig
          type 'a t =
              ('a Bddapron.Env.t, 'a Bddapron.Expr0.Apron.t)
              Bddapron.Env.value
          val of_expr0 :
            'a Bddapron.Env.t ->
            'a Bddapron.Expr0.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val get_env : 'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Env.t
          val to_expr0 :
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr0.Apron.t
          val of_expr : 'a Bddapron.Expr1.expr -> 'a Bddapron.Expr1.Apron.t
          val to_expr : 'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.expr
          val extend_environment :
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Env.t -> 'a Bddapron.Expr1.Apron.t
          val var :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr1.Apron.t
          val cst :
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> Apron.Coeff.t -> 'a Bddapron.Expr1.Apron.t
          val add :
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val mul :
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val sub :
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val div :
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val gmod :
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val negate :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val sqrt :
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val cast :
            'a Bddapron.Cond.t ->
            ?typ:Apron.Texpr1.typ ->
            ?round:Apron.Texpr1.round ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val ite :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t ->
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Apron.t
          val condition :
            'a Bddapron.Cond.t ->
            Apron.Tcons1.typ ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Bool.t
          val supeq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Bool.t
          val sup :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Bool.t
          val eq :
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Apron.t -> 'a Bddapron.Expr1.Bool.t
          val cofactor :
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Apron.t
          val restrict :
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Apron.t
          val tdrestrict :
            'a Bddapron.Expr1.Apron.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.Apron.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Apron.t ->
            ('a * 'a) list -> 'a Bddapron.Expr1.Apron.t
          val substitute :
            ?memo:Cudd.Memo.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Apron.t ->
            ('a * 'a Bddapron.Expr1.expr) list -> 'a Bddapron.Expr1.Apron.t
          val print :
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr1.Apron.t -> unit
        end
      val typ_of_expr : 'a Bddapron.Expr1.t -> 'a Bddapron.Env.typ
      val make :
        'a Bddapron.Env.t -> 'a Bddapron.Expr0.t -> 'a Bddapron.Expr1.t
      val of_expr0 :
        'a Bddapron.Env.t -> 'a Bddapron.Expr0.t -> 'a Bddapron.Expr1.t
      val get_env : 'a Bddapron.Expr1.t -> 'a Bddapron.Env.t
      val to_expr0 : 'a Bddapron.Expr1.t -> 'a Bddapron.Expr0.t
      val extend_environment :
        'a Bddapron.Expr1.t -> 'a Bddapron.Env.t -> 'a Bddapron.Expr1.t
      val var :
        'a Bddapron.Env.t -> 'a Bddapron.Cond.t -> 'a -> 'a Bddapron.Expr1.t
      val ite :
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr1.Bool.t ->
        'a Bddapron.Expr1.t -> 'a Bddapron.Expr1.t -> 'a Bddapron.Expr1.t
      val eq :
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr1.t ->
        'a Bddapron.Expr1.t -> 'a Bddapron.Expr1.Bool.t
      val substitute_by_var :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr1.t -> ('a * 'a) list -> 'a Bddapron.Expr1.t
      val substitute_by_var_list :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr1.t list ->
        ('a * 'a) list -> 'a Bddapron.Expr1.t list
      val substitute :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr1.t ->
        ('a * 'a Bddapron.Expr1.t) list -> 'a Bddapron.Expr1.t
      val substitute_list :
        ?memo:Cudd.Memo.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Expr1.t list ->
        ('a * 'a Bddapron.Expr1.t) list -> 'a Bddapron.Expr1.t list
      val support : 'a Bddapron.Cond.t -> 'a Bddapron.Expr1.t -> 'a PSette.t
      val support_cond : Cudd.Man.vt -> 'a Bddapron.Expr1.t -> Cudd.Bdd.vt
      val cofactor :
        'a Bddapron.Expr1.t ->
        'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.t
      val restrict :
        'a Bddapron.Expr1.t ->
        'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.t
      val tdrestrict :
        'a Bddapron.Expr1.t ->
        'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr1.t
      val print :
        'a Bddapron.Cond.t -> Format.formatter -> 'a Bddapron.Expr1.t -> unit
      val normalize :
        ?reduce:bool ->
        ?careset:bool ->
        'a Bddapron.Cond.t * 'a Bddapron.Expr1.t list ->
        'a Bddapron.Cond.t * 'a Bddapron.Expr1.t list
      module List :
        sig
          type 'a t =
              ('a Bddapron.Env.t, 'a Bddapron.Expr0.t list)
              Bddapron.Env.value
          val of_lexpr0 :
            'a Bddapron.Env.t ->
            'a Bddapron.Expr0.t list -> 'a Bddapron.Expr1.List.t
          val get_env : 'a Bddapron.Expr1.List.t -> 'a Bddapron.Env.t
          val to_lexpr0 :
            'a Bddapron.Expr1.List.t -> 'a Bddapron.Expr0.t list
          val of_lexpr :
            'a Bddapron.Env.t ->
            'a Bddapron.Expr1.expr list -> 'a Bddapron.Expr1.List.t
          val to_lexpr :
            'a Bddapron.Expr1.List.t -> 'a Bddapron.Expr1.expr list
          val extend_environment :
            'a Bddapron.Expr1.List.t ->
            'a Bddapron.Env.t -> 'a Bddapron.Expr1.List.t
          val normalize :
            ?reduce:bool ->
            ?careset:bool ->
            'a Bddapron.Cond.t * 'a Bddapron.Expr1.List.t ->
            'a Bddapron.Cond.t * 'a Bddapron.Expr1.List.t
          val print :
            ?first:(unit, Format.formatter, unit) Pervasives.format ->
            ?sep:(unit, Format.formatter, unit) Pervasives.format ->
            ?last:(unit, Format.formatter, unit) Pervasives.format ->
            'a Bddapron.Cond.t ->
            Format.formatter -> 'a Bddapron.Expr1.List.t -> unit
        end
      module O :
        sig
          type ('a, 'b) t = ('b, 'a Bddapron.Expr0.t) Bddapron.Env.value
            constraint 'b =
              ('a, [> 'a Bddapron.Env.typ ] as 'c,
               [> 'a Bddapron.Env.typdef ] as 'd, 'e)
              Bddapron.Env.O.t
          type ('a, 'b) expr = ('a, 'b) Bddapron.Expr1.O.t
            constraint 'b =
              ('a, [> 'a Bddapron.Env.typ ] as 'c,
               [> 'a Bddapron.Env.typdef ] as 'd, 'e)
              Bddapron.Env.O.t
          module Bool :
            sig
              type ('a, 'b) t =
                  ('b, 'a Bddapron.Expr0.Bool.t) Bddapron.Env.value
                constraint 'b =
                  ('a, [> 'a Bddapron.Env.typ ] as 'c,
                   [> 'a Bddapron.Env.typdef ] as 'd, 'e)
                  Bddapron.Env.O.t
              val of_expr :
                (('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t, [> `Bool of 'a Bddapron.Expr0.Bool.t ])
                Bddapron.Env.value ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val to_expr :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                (('a, 'b, 'c, 'd) Bddapron.Env.O.t,
                 [> `Bool of 'a Bddapron.Expr0.Bool.t ])
                Bddapron.Env.value
              val extend_environment :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val dtrue :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val dfalse :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val of_bool :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                bool ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val dnot :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val dand :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val dor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val xor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val nand :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val nor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val nxor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val eq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val leq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val ite :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val is_true :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t -> bool
              val is_false :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t -> bool
              val is_cst :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t -> bool
              val is_eq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t -> bool
              val is_leq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t -> bool
              val is_inter_false :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t -> bool
              val exist :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                'a list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val forall :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                'a list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val cofactor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val restrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val tdrestrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a * 'a) list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a *
                 ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                 Bddapron.Expr1.O.expr)
                list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val print :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                Format.formatter ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t -> unit
            end
          module Bint :
            sig
              type ('a, 'b) t = ('b, Cudd.Man.v Bdd.Int.t) Bddapron.Env.value
                constraint 'b =
                  ('a, [> 'a Bddapron.Env.typ ] as 'c,
                   [> 'a Bddapron.Env.typdef ] as 'd, 'e)
                  Bddapron.Env.O.t
              val of_expr :
                (('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t, [> `Bint of 'a Bddapron.Expr0.Bint.t ])
                Bddapron.Env.value ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val to_expr :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                (('a, 'b, 'c, 'd) Bddapron.Env.O.t,
                 [> `Bint of 'a Bddapron.Expr0.Bint.t ])
                Bddapron.Env.value
              val extend_environment :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val of_int :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                [ `Bint of bool * int ] ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val neg :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val succ :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val pred :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val add :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val sub :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val mul :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val shift_left :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val shift_right :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val scale :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val ite :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val zero :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val eq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val supeq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val sup :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val eq_int :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val supeq_int :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val sup_int :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val cofactor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val restrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val tdrestrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a * 'a) list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                ('a *
                 ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                 Bddapron.Expr1.O.expr)
                list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t
              val guard_of_int :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                int ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val guardints :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t ->
                (('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                 Bddapron.Expr1.O.Bool.t * int)
                list
              val print :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                Format.formatter ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bint.t -> unit
            end
          module Benum :
            sig
              type ('a, 'b) t =
                  ('b, Cudd.Man.v Bdd.Enum.t) Bddapron.Env.value
                constraint 'b =
                  ('a, [> 'a Bddapron.Env.typ ] as 'c,
                   [> 'a Bddapron.Env.typdef ] as 'd, 'e)
                  Bddapron.Env.O.t
              val of_expr :
                (('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t, [> `Benum of 'a Bddapron.Expr0.Benum.t ])
                Bddapron.Env.value ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val to_expr :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                (('a, 'b, 'c, 'd) Bddapron.Env.O.t,
                 [> `Benum of 'a Bddapron.Expr0.Benum.t ])
                Bddapron.Env.value
              val extend_environment :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val ite :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val eq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val eq_label :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                'a ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val cofactor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val restrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val tdrestrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a * 'a) list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                ('a *
                 ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                 Bddapron.Expr1.O.expr)
                list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t
              val guard_of_label :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                'a ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val guardlabels :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t ->
                (('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                 Bddapron.Expr1.O.Bool.t * 'a)
                list
              val print :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                Format.formatter ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Benum.t -> unit
            end
          module Apron :
            sig
              type ('a, 'b) t =
                  ('b, 'a Bddapron.Expr0.Apron.t) Bddapron.Env.value
                constraint 'b =
                  ('a, [> 'a Bddapron.Env.typ ] as 'c,
                   [> 'a Bddapron.Env.typdef ] as 'd, 'e)
                  Bddapron.Env.O.t
              val of_expr :
                (('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t, [> `Apron of 'a Bddapron.Expr0.Apron.t ])
                Bddapron.Env.value ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val to_expr :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                (('a, 'b, 'c, 'd) Bddapron.Env.O.t,
                 [> `Apron of 'a Bddapron.Expr0.Apron.t ])
                Bddapron.Env.value
              val extend_environment :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val var :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val cst :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                Bddapron.Expr1.apron_coeff ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val add :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr1.apron_typ ->
                ?round:Bddapron.Expr1.apron_round ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val mul :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr1.apron_typ ->
                ?round:Bddapron.Expr1.apron_round ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val sub :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr1.apron_typ ->
                ?round:Bddapron.Expr1.apron_round ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val div :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr1.apron_typ ->
                ?round:Bddapron.Expr1.apron_round ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val gmod :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr1.apron_typ ->
                ?round:Bddapron.Expr1.apron_round ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val negate :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val sqrt :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr1.apron_typ ->
                ?round:Bddapron.Expr1.apron_round ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val cast :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ?typ:Bddapron.Expr1.apron_typ ->
                ?round:Bddapron.Expr1.apron_round ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val ite :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val condition :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                Bddapron.Expr1.apron_cons_typ ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val supeq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val sup :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val eq :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val cofactor :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val restrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val tdrestrict :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val substitute_by_var :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a * 'a) list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val substitute :
                ?memo:Cudd.Memo.t ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t ->
                ('a *
                 ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                 Bddapron.Expr1.O.expr)
                list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t
              val print :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                Format.formatter ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Apron.t -> unit
            end
          val typ_of_expr :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'b)
             Bddapron.Env.O.t)
            Bddapron.Expr1.O.t -> 'a Bddapron.Env.typ
          val make :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            'a Bddapron.Expr0.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val extend_environment :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr1.O.t ->
            ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val var :
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a -> ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val ite :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.Bool.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val eq :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.Bool.t
          val substitute_by_var :
            ?memo:Cudd.Memo.t ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            ('a * 'a) list ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val substitute_by_var_list :
            ?memo:Cudd.Memo.t ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t list ->
            ('a * 'a) list ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t list
          val substitute :
            ?memo:Cudd.Memo.t ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            ('a * ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t)
            list ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val substitute_list :
            ?memo:Cudd.Memo.t ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t list ->
            ('a * ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t)
            list ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t list
          val support :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            'a PSette.t
          val support_cond :
            Cudd.Man.vt ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'b)
             Bddapron.Env.O.t)
            Bddapron.Expr1.O.t -> Cudd.Bdd.vt
          val cofactor :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.Bool.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val restrict :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.Bool.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val tdrestrict :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.Bool.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val print :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            Format.formatter ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            unit
          val normalize :
            ?reduce:bool ->
            ?careset:bool ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t *
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t list ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t *
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t list
          module List :
            sig
              type ('a, 'b) t =
                  ('b, 'a Bddapron.Expr0.t list) Bddapron.Env.value
                constraint 'b =
                  ('a, [> 'a Bddapron.Env.typ ] as 'c,
                   [> 'a Bddapron.Env.typdef ] as 'd, 'e)
                  Bddapron.Env.O.t
              val of_lexpr0 :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                'a Bddapron.Expr0.t list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t
              val get_env :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
              val to_lexpr0 :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ],
                  'b)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t -> 'a Bddapron.Expr0.t list
              val of_lexpr :
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.expr
                list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t
              val to_lexpr :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.expr
                list
              val extend_environment :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t ->
                ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t
              val normalize :
                ?reduce:bool ->
                ?careset:bool ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t *
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t *
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t
              val print :
                ?first:(unit, Format.formatter, unit) Pervasives.format ->
                ?sep:(unit, Format.formatter, unit) Pervasives.format ->
                ?last:(unit, Format.formatter, unit) Pervasives.format ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                Format.formatter ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t -> unit
            end
        end
    end
  module Expr2 :
    sig
      module O :
        sig
          module Bool :
            sig
              type ('a, 'b) t =
                  (('a, 'b) Bddapron.Cond.O.t,
                   ('a, 'b) Bddapron.Expr1.O.Bool.t)
                  Bdd.Cond.value
                constraint 'b =
                  ('a, [> 'a Bddapron.Env.typ ] as 'c,
                   [> 'a Bddapron.Env.typdef ] as 'd, 'e)
                  Bddapron.Env.O.t
              val of_expr0 :
                ?normalize:bool ->
                ?reduce:bool ->
                ?careset:bool ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t
              val of_expr1 :
                ?normalize:bool ->
                ?reduce:bool ->
                ?careset:bool ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t
              val get_env :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
              val get_cond :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t
              val to_expr0 :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ],
                  'b)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t -> 'a Bddapron.Expr0.Bool.t
              val to_expr1 :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.Bool.t
              val of_expr :
                (('a,
                  ('a, [> 'a Bddapron.Env.typ ] as 'b,
                   [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                  Bddapron.Env.O.t)
                 Bddapron.Cond.O.t,
                 (('a, 'b, 'c, 'd) Bddapron.Env.O.t,
                  [> `Bool of 'a Bddapron.Expr0.Bool.t ])
                 Bddapron.Env.value)
                Bdd.Cond.value ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t
              val to_expr :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t ->
                (('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t,
                 (('a, 'b, 'c, 'd) Bddapron.Env.O.t,
                  [> `Bool of 'a Bddapron.Expr0.Bool.t ])
                 Bddapron.Env.value)
                Bdd.Cond.value
              val extend_environment :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t ->
                ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t
              val is_false :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ],
                  'b)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t -> bool
              val is_true :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ],
                  'b)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t -> bool
              val print :
                Format.formatter ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ],
                  'b)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.Bool.t -> unit
            end
          type ('a, 'b) t =
              (('a, 'b) Bddapron.Cond.O.t, ('a, 'b) Bddapron.Expr1.O.t)
              Bdd.Cond.value
            constraint 'b =
              ('a, [> 'a Bddapron.Env.typ ] as 'c,
               [> 'a Bddapron.Env.typdef ] as 'd, 'e)
              Bddapron.Env.O.t
          type ('a, 'b) expr = ('a, 'b) Bddapron.Expr2.O.t
            constraint 'b =
              ('a, [> 'a Bddapron.Env.typ ] as 'c,
               [> 'a Bddapron.Env.typdef ] as 'd, 'e)
              Bddapron.Env.O.t
          val of_expr0 :
            ?normalize:bool ->
            ?reduce:bool ->
            ?careset:bool ->
            ('a, [> 'a Bddapron.Env.typ ] as 'b,
             [> 'a Bddapron.Env.typdef ] as 'c, 'd)
            Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'a Bddapron.Expr0.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr2.O.t
          val of_expr1 :
            ?normalize:bool ->
            ?reduce:bool ->
            ?careset:bool ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Cond.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr2.O.t
          val get_env :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr2.O.t -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
          val get_cond :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr2.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t
          val to_expr0 :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'b)
             Bddapron.Env.O.t)
            Bddapron.Expr2.O.t -> 'a Bddapron.Expr0.t
          val to_expr1 :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr2.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
          val extend_environment :
            ('a,
             ('a, [> 'a Bddapron.Env.typ ] as 'b,
              [> 'a Bddapron.Env.typdef ] as 'c, 'd)
             Bddapron.Env.O.t)
            Bddapron.Expr2.O.t ->
            ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
            ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr2.O.t
          val print :
            Format.formatter ->
            ('a,
             ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'b)
             Bddapron.Env.O.t)
            Bddapron.Expr2.O.t -> unit
          module List :
            sig
              type ('a, 'b) t =
                  (('a, 'b) Bddapron.Cond.O.t,
                   ('a, 'b) Bddapron.Expr1.O.List.t)
                  Bdd.Cond.value
                constraint 'b =
                  ('a, [> 'a Bddapron.Env.typ ] as 'c,
                   [> 'a Bddapron.Env.typdef ] as 'd, 'e)
                  Bddapron.Env.O.t
              val of_lexpr0 :
                ?normalize:bool ->
                ?reduce:bool ->
                ?careset:bool ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Expr0.t list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t
              val of_lexpr1 :
                ?normalize:bool ->
                ?reduce:bool ->
                ?careset:bool ->
                ('a, [> 'a Bddapron.Env.typ ] as 'b,
                 [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
                list ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t
              val of_listexpr1 :
                ?normalize:bool ->
                ?reduce:bool ->
                ?careset:bool ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Cond.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t
              val get_env :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t -> ('a, 'b, 'c, 'd) Bddapron.Env.O.t
              val get_cond :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t
              val to_lexpr0 :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ],
                  'b)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t -> 'a Bddapron.Expr0.t list
              val to_lexpr1 :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Expr1.O.t
                list
              val to_listexpr1 :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr1.O.List.t
              val extend_environment :
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ] as 'b,
                  [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t ->
                ('a, 'b, 'c, 'd) Bddapron.Env.O.t ->
                ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t
              val print :
                Format.formatter ->
                ('a,
                 ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ],
                  'b)
                 Bddapron.Env.O.t)
                Bddapron.Expr2.O.List.t -> unit
            end
        end
      type 'a t = ('a Bddapron.Cond.t, 'a Bddapron.Expr1.t) Bdd.Cond.value
      type 'a expr = 'a Bddapron.Expr2.t
      val of_expr0 :
        ?normalize:bool ->
        ?reduce:bool ->
        ?careset:bool ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t -> 'a Bddapron.Expr0.t -> 'a Bddapron.Expr2.t
      val of_expr1 :
        ?normalize:bool ->
        ?reduce:bool ->
        ?careset:bool ->
        'a Bddapron.Cond.t -> 'a Bddapron.Expr1.t -> 'a Bddapron.Expr2.t
      val get_env : 'a Bddapron.Expr2.t -> 'a Bddapron.Env.t
      val get_cond : 'a Bddapron.Expr2.t -> 'a Bddapron.Cond.t
      val to_expr0 : 'a Bddapron.Expr2.t -> 'a Bddapron.Expr0.t
      val to_expr1 : 'a Bddapron.Expr2.t -> 'a Bddapron.Expr1.t
      val extend_environment :
        'a Bddapron.Expr2.t -> 'a Bddapron.Env.t -> 'a Bddapron.Expr2.t
      val print : Format.formatter -> 'a Bddapron.Expr2.t -> unit
      module Bool :
        sig
          type 'a t =
              ('a Bddapron.Cond.t, 'a Bddapron.Expr1.Bool.t) Bdd.Cond.value
          val of_expr0 :
            ?normalize:bool ->
            ?reduce:bool ->
            ?careset:bool ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.Bool.t -> 'a Bddapron.Expr2.Bool.t
          val of_expr1 :
            ?normalize:bool ->
            ?reduce:bool ->
            ?careset:bool ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.Bool.t -> 'a Bddapron.Expr2.Bool.t
          val get_env : 'a Bddapron.Expr2.Bool.t -> 'a Bddapron.Env.t
          val get_cond : 'a Bddapron.Expr2.Bool.t -> 'a Bddapron.Cond.t
          val to_expr0 : 'a Bddapron.Expr2.Bool.t -> 'a Bddapron.Expr0.Bool.t
          val to_expr1 : 'a Bddapron.Expr2.Bool.t -> 'a Bddapron.Expr1.Bool.t
          val of_expr : 'a Bddapron.Expr2.expr -> 'a Bddapron.Expr2.Bool.t
          val to_expr : 'a Bddapron.Expr2.Bool.t -> 'a Bddapron.Expr2.expr
          val extend_environment :
            'a Bddapron.Expr2.Bool.t ->
            'a Bddapron.Env.t -> 'a Bddapron.Expr2.Bool.t
          val is_false : 'a Bddapron.Expr2.Bool.t -> bool
          val is_true : 'a Bddapron.Expr2.Bool.t -> bool
          val print : Format.formatter -> 'a Bddapron.Expr2.Bool.t -> unit
        end
      module List :
        sig
          type 'a t =
              ('a Bddapron.Cond.t, 'a Bddapron.Expr1.List.t) Bdd.Cond.value
          val of_lexpr0 :
            ?normalize:bool ->
            ?reduce:bool ->
            ?careset:bool ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr0.t list -> 'a Bddapron.Expr2.List.t
          val of_lexpr1 :
            ?normalize:bool ->
            ?reduce:bool ->
            ?careset:bool ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.t list -> 'a Bddapron.Expr2.List.t
          val of_listexpr1 :
            ?normalize:bool ->
            ?reduce:bool ->
            ?careset:bool ->
            'a Bddapron.Cond.t ->
            'a Bddapron.Expr1.List.t -> 'a Bddapron.Expr2.List.t
          val get_env : 'a Bddapron.Expr2.List.t -> 'a Bddapron.Env.t
          val get_cond : 'a Bddapron.Expr2.List.t -> 'a Bddapron.Cond.t
          val to_lexpr0 :
            'a Bddapron.Expr2.List.t -> 'a Bddapron.Expr0.t list
          val to_listexpr1 :
            'a Bddapron.Expr2.List.t -> 'a Bddapron.Expr1.List.t
          val to_lexpr1 :
            'a Bddapron.Expr2.List.t -> 'a Bddapron.Expr1.t list
          val extend_environment :
            'a Bddapron.Expr2.List.t ->
            'a Bddapron.Env.t -> 'a Bddapron.Expr2.List.t
          val print : Format.formatter -> 'a Bddapron.Expr2.List.t -> unit
        end
    end
  module Descend :
    sig
      val texpr_cofactor :
        ('a Bddapron.Expr0.t -> 'b -> 'a Bddapron.Expr0.t) ->
        'a Bddapron.Expr0.t array -> 'b -> 'a Bddapron.Expr0.t array
      val texpr_support :
        ('a,
         ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'b)
         Bddapron.Env.O.t)
        Bddapron.Cond.O.t ->
        'a Bddapron.Expr0.t array -> Cudd.Man.v Cudd.Bdd.t
      val texpr_cofactors :
        ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'd)
        Bddapron.Env.O.t ->
        'a Bddapron.Expr0.t array ->
        int -> 'a Bddapron.Expr0.t array * 'a Bddapron.Expr0.t array
      val split_lvar :
        'a Bdd.Env.symbol ->
        'a list -> 'a Bddapron.Expr0.t list -> 'a list * Apron.Var.t array
      val split_texpr :
        'a Bddapron.Expr0.t array ->
        Cudd.Man.v Bdd.Expr0.t list * 'a Bddapron.ApronexprDD.t array
      val split_lvarlexpr :
        'a Bdd.Env.symbol ->
        'a list ->
        'a Bddapron.Expr0.t list ->
        'a list * Cudd.Man.v Bdd.Expr0.t list * Apron.Var.t array *
        'a Bddapron.ApronexprDD.t array
      val cofactors :
        'a Bddapron.ApronDD.man ->
        ('b, [> 'b Bddapron.Env.typ ] as 'c,
         [> 'b Bddapron.Env.typdef ] as 'd, 'e)
        Bddapron.Env.O.t ->
        ('b, ('b, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
        'a Bddapron.ApronDD.t ->
        int -> 'a Bddapron.ApronDD.t * 'a Bddapron.ApronDD.t
      val descend_mtbdd :
        'a Bddapron.ApronDD.man ->
        ('b, [> 'b Bddapron.Env.typ ] as 'c,
         [> 'b Bddapron.Env.typdef ] as 'd, 'e)
        Bddapron.Env.O.t ->
        ('b, ('b, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
        ('a Bddapron.ApronDD.t ->
         'b Bddapron.Expr0.t array -> 'a Bddapron.ApronDD.t) ->
        'a Bddapron.ApronDD.t ->
        'b Bddapron.Expr0.t array -> 'a Bddapron.ApronDD.t
      val descend :
        cudd:'c Cudd.Man.t ->
        maxdepth:int ->
        nocare:('a -> bool) ->
        cube_of_down:('a -> 'c Cudd.Bdd.t) ->
        cofactor:('a -> 'c Cudd.Bdd.t -> 'a) ->
        select:('a -> int) ->
        terminal:(depth:int ->
                  newcube:'c Cudd.Bdd.t ->
                  cube:'c Cudd.Bdd.t -> down:'a -> 'b option) ->
        ite:(depth:int ->
             newcube:'c Cudd.Bdd.t ->
             cond:int -> dthen:'b option -> delse:'b option -> 'b option) ->
        down:'a -> 'b option
    end
  module Mtbdddomain0 :
    sig
      type ('a, 'b) man = 'b Bddapron.ApronDD.man
      type 'b t = 'b Bddapron.ApronDD.t
      val make_man :
        ?global:bool ->
        'b Apron.Manager.t -> ('a, 'b) Bddapron.Mtbdddomain0.man
      val size :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t -> int
      val print :
        ?print_apron:((int -> string) ->
                      Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
        'a Bddapron.Env.t ->
        Format.formatter -> 'b Bddapron.Mtbdddomain0.t -> unit
      val bottom :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t -> 'b Bddapron.Mtbdddomain0.t
      val top :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t -> 'b Bddapron.Mtbdddomain0.t
      val of_apron :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t ->
        'b Apron.Abstract0.t -> 'b Bddapron.Mtbdddomain0.t
      val of_bddapron :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t ->
        ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list ->
        'b Bddapron.Mtbdddomain0.t
      val is_bottom :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t -> bool
      val is_top :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t -> bool
      val is_leq :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t -> bool
      val is_eq :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t -> bool
      val to_bddapron :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t ->
        ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list
      val meet :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t ->
        'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t
      val join :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t ->
        'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t
      val meet_condition :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'b Bddapron.Mtbdddomain0.t ->
        'a Bddapron.Expr0.Bool.t -> 'b Bddapron.Mtbdddomain0.t
      val assign_lexpr :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'b Bddapron.Mtbdddomain0.t ->
        'a list ->
        'a Bddapron.Expr0.t list ->
        'b Bddapron.Mtbdddomain0.t option -> 'b Bddapron.Mtbdddomain0.t
      val substitute_lexpr :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'b Bddapron.Mtbdddomain0.t ->
        'a list ->
        'a Bddapron.Expr0.t list ->
        'b Bddapron.Mtbdddomain0.t option -> 'b Bddapron.Mtbdddomain0.t
      val forget_list :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'a Bddapron.Env.t ->
        'b Bddapron.Mtbdddomain0.t -> 'a list -> 'b Bddapron.Mtbdddomain0.t
      val widening :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t ->
        'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t
      val widening_threshold :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t ->
        'b Bddapron.Mtbdddomain0.t ->
        Apron.Lincons0.t array -> 'b Bddapron.Mtbdddomain0.t
      val apply_change :
        bottom:'b Bddapron.Mtbdddomain0.t ->
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t ->
        Bddapron.Env.change -> 'b Bddapron.Mtbdddomain0.t
      val apply_permutation :
        ('a, 'b) Bddapron.Mtbdddomain0.man ->
        'b Bddapron.Mtbdddomain0.t ->
        int array option * Apron.Dim.perm option ->
        'b Bddapron.Mtbdddomain0.t
      module O :
        sig
          val meet_idcondb :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ] as 'c,
             [> 'a Bddapron.Env.typdef ] as 'd, 'e)
            Bddapron.Env.O.t ->
            ('a, ('a, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'b Bddapron.Mtbdddomain0.t ->
            int * bool -> 'b Bddapron.Mtbdddomain0.t
          val size :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t -> int
          val print :
            ?print_apron:((int -> string) ->
                          Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            Format.formatter -> 'b Bddapron.Mtbdddomain0.t -> unit
          val bottom :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t -> 'b Bddapron.Mtbdddomain0.t
          val top :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t -> 'b Bddapron.Mtbdddomain0.t
          val of_apron :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            'b Apron.Abstract0.t -> 'b Bddapron.Mtbdddomain0.t
          val of_bddapron :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list ->
            'b Bddapron.Mtbdddomain0.t
          val is_bottom :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t -> bool
          val is_top :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t -> bool
          val is_leq :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t -> bool
          val is_eq :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t -> bool
          val to_bddapron :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t ->
            ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list
          val meet :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t ->
            'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t
          val join :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t ->
            'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t
          val meet_condition :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ] as 'c,
             [> 'a Bddapron.Env.typdef ] as 'd, 'e)
            Bddapron.Env.O.t ->
            ('a, ('a, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'b Bddapron.Mtbdddomain0.t ->
            'a Bddapron.Expr0.Bool.t -> 'b Bddapron.Mtbdddomain0.t
          val assign_lexpr :
            ?relational:bool ->
            ?nodependency:bool ->
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ] as 'c,
             [> 'a Bddapron.Env.typdef ] as 'd, 'e)
            Bddapron.Env.O.t ->
            ('a, ('a, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'b Bddapron.Mtbdddomain0.t ->
            'a list ->
            'a Bddapron.Expr0.t list ->
            'b Bddapron.Mtbdddomain0.t option -> 'b Bddapron.Mtbdddomain0.t
          val substitute_lexpr :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ] as 'c,
             [> 'a Bddapron.Env.typdef ] as 'd, 'e)
            Bddapron.Env.O.t ->
            ('a, ('a, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'b Bddapron.Mtbdddomain0.t ->
            'a list ->
            'a Bddapron.Expr0.t list ->
            'b Bddapron.Mtbdddomain0.t option -> 'b Bddapron.Mtbdddomain0.t
          val forget_list :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            'b Bddapron.Mtbdddomain0.t ->
            'a list -> 'b Bddapron.Mtbdddomain0.t
          val widening :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t ->
            'b Bddapron.Mtbdddomain0.t -> 'b Bddapron.Mtbdddomain0.t
          val widening_threshold :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t ->
            'b Bddapron.Mtbdddomain0.t ->
            Apron.Lincons0.t array -> 'b Bddapron.Mtbdddomain0.t
          val apply_change :
            bottom:'b Bddapron.Mtbdddomain0.t ->
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t ->
            Bddapron.Env.change -> 'b Bddapron.Mtbdddomain0.t
          val apply_permutation :
            ('a, 'b) Bddapron.Mtbdddomain0.man ->
            'b Bddapron.Mtbdddomain0.t ->
            int array option * Apron.Dim.perm option ->
            'b Bddapron.Mtbdddomain0.t
        end
    end
  module Bddleaf :
    sig
      type ('a, 'b) elt = { guard : 'a Cudd.Bdd.t; leaf : 'b; }
      type ('a, 'b) t = ('a, 'b) Bddapron.Bddleaf.elt list
      val fold2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
      val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
      val check_unicity :
        is_equal:('b -> 'b -> bool) ->
        ('a, 'b) Bddapron.Bddleaf.elt list -> bool
      val check_disjointness : ('a, 'b) Bddapron.Bddleaf.elt list -> bool
      val cons_unique :
        is_equal:('b -> 'b -> bool) ->
        ('a, 'b) Bddapron.Bddleaf.elt ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list
      val append_unique :
        is_equal:('b -> 'b -> bool) ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list
      val cons_disjoint :
        is_equal:('b -> 'b -> bool) ->
        merge:('b -> 'b -> 'b) ->
        ('a, 'b) Bddapron.Bddleaf.elt ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list
      val append_disjoint :
        is_equal:('b -> 'b -> bool) ->
        merge:('b -> 'b -> 'b) ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list
      val cons :
        is_equal:('b -> 'b -> bool) ->
        merge:('b -> 'b -> 'b) ->
        unique:bool ->
        disjoint:bool ->
        ('a, 'b) Bddapron.Bddleaf.elt ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list
      val append :
        is_equal:('b -> 'b -> bool) ->
        merge:('b -> 'b -> 'b) ->
        unique:bool ->
        disjoint:bool ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list
      val make_unique :
        is_equal:('b -> 'b -> bool) ->
        merge:('b -> 'b -> 'b) ->
        disjoint:bool ->
        ('a, 'b) Bddapron.Bddleaf.elt list ->
        ('a, 'b) Bddapron.Bddleaf.elt list
      val guard :
        cudd:'a Cudd.Man.t -> ('a, 'b) Bddapron.Bddleaf.t -> 'a Cudd.Bdd.t
    end
  module Bdddomain0 :
    sig
      type ('a, 'b) man = {
        apron : 'b Apron.Manager.t;
        mutable bdd_restrict : Cudd.Bdd.vt -> Cudd.Bdd.vt -> Cudd.Bdd.vt;
        mutable expr_restrict :
          'a Bddapron.Expr0.t -> Cudd.Bdd.vt -> 'a Bddapron.Expr0.t;
        mutable meet_disjoint : bool;
        mutable join_disjoint : bool;
        mutable meet_cond_unique : bool;
        mutable meet_cond_disjoint : bool;
        mutable meet_cond_depth : int;
        mutable assign_unique : bool;
        mutable assign_disjoint : bool;
        mutable substitute_unique : bool;
        mutable substitute_disjoint : bool;
        mutable forget_unique : bool;
        mutable forget_disjoint : bool;
        mutable change_environment_unique : bool;
        mutable change_environment_disjoint : bool;
      }
      type 'b elt = (Cudd.Man.v, 'b Apron.Abstract0.t) Bddapron.Bddleaf.elt
      type 'b t = {
        mutable list : 'b Bddapron.Bdddomain0.elt list;
        bottom : 'b Bddapron.Bdddomain0.elt;
        mutable unique : bool;
        mutable disjoint : bool;
      }
      val make_man : 'b Apron.Manager.t -> ('a, 'b) Bddapron.Bdddomain0.man
      val canonicalize :
        ?apron:bool ->
        ?unique:bool ->
        ?disjoint:bool ->
        ('a, 'b) Bddapron.Bdddomain0.man -> 'b Bddapron.Bdddomain0.t -> unit
      val size :
        ('a, 'b) Bddapron.Bdddomain0.man -> 'b Bddapron.Bdddomain0.t -> int
      val print :
        ?print_apron:((int -> string) ->
                      Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
        'a Bddapron.Env.t ->
        Format.formatter -> 'b Bddapron.Bdddomain0.t -> unit
      val bottom :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t -> 'b Bddapron.Bdddomain0.t
      val top :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t -> 'b Bddapron.Bdddomain0.t
      val of_apron :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t -> 'b Apron.Abstract0.t -> 'b Bddapron.Bdddomain0.t
      val of_bddapron :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t ->
        ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list ->
        'b Bddapron.Bdddomain0.t
      val is_bottom :
        ('a, 'b) Bddapron.Bdddomain0.man -> 'b Bddapron.Bdddomain0.t -> bool
      val is_top :
        ('a, 'b) Bddapron.Bdddomain0.man -> 'b Bddapron.Bdddomain0.t -> bool
      val is_leq :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t -> bool
      val is_eq :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t -> bool
      val to_bddapron :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t ->
        ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list
      val meet :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t ->
        'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t
      val join :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t ->
        'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t
      val meet_condition :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'b Bddapron.Bdddomain0.t ->
        'a Bddapron.Expr0.Bool.t -> 'b Bddapron.Bdddomain0.t
      val assign_lexpr :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'b Bddapron.Bdddomain0.t ->
        'a list ->
        'a Bddapron.Expr0.t list ->
        'b Bddapron.Bdddomain0.t option -> 'b Bddapron.Bdddomain0.t
      val substitute_lexpr :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'b Bddapron.Bdddomain0.t ->
        'a list ->
        'a Bddapron.Expr0.t list ->
        'b Bddapron.Bdddomain0.t option -> 'b Bddapron.Bdddomain0.t
      val forget_list :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'a Bddapron.Env.t ->
        'b Bddapron.Bdddomain0.t -> 'a list -> 'b Bddapron.Bdddomain0.t
      val widening :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t ->
        'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t
      val widening_threshold :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t ->
        'b Bddapron.Bdddomain0.t ->
        Apron.Lincons0.t array -> 'b Bddapron.Bdddomain0.t
      val apply_change :
        bottom:'b Bddapron.Bdddomain0.t ->
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t ->
        Bddapron.Env.change -> 'b Bddapron.Bdddomain0.t
      val apply_permutation :
        ('a, 'b) Bddapron.Bdddomain0.man ->
        'b Bddapron.Bdddomain0.t ->
        int array option * Apron.Dim.perm option -> 'b Bddapron.Bdddomain0.t
      module O :
        sig
          module L :
            sig
              val is_bottom :
                'a Apron.Manager.t -> 'a Bddapron.Bdddomain0.elt -> bool
              val meet_cube :
                'a Apron.Manager.t ->
                ('b, [> 'b Bddapron.Env.typ ] as 'c,
                 [> 'b Bddapron.Env.typdef ] as 'd, 'e)
                Bddapron.Env.O.t ->
                ('b, ('b, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                'a Bddapron.Bdddomain0.elt ->
                Cudd.Bdd.vt -> 'a Bddapron.Bdddomain0.elt
              val forget :
                'a Apron.Manager.t ->
                'a Bddapron.Bdddomain0.elt ->
                Cudd.Bdd.vt ->
                Apron.Dim.t array -> 'a Bddapron.Bdddomain0.elt
            end
          val check_wellformed :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t -> bool
          val canonicalize :
            ?apron:bool ->
            ?unique:bool ->
            ?disjoint:bool ->
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t -> unit
          val size :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t -> int
          val print :
            ?print_apron:((int -> string) ->
                          Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            Format.formatter -> 'b Bddapron.Bdddomain0.t -> unit
          val bottom :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t -> 'b Bddapron.Bdddomain0.t
          val top :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t -> 'b Bddapron.Bdddomain0.t
          val of_apron :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            'b Apron.Abstract0.t -> 'b Bddapron.Bdddomain0.t
          val of_bddapron :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list ->
            'b Bddapron.Bdddomain0.t
          val is_bottom :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t -> bool
          val is_top :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t -> bool
          val is_leq :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t -> bool
          val is_eq :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t -> bool
          val to_bddapron :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t ->
            ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list
          val meet :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t ->
            'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t
          val join :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t ->
            'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t
          val meet_condition :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ] as 'c,
             [> 'a Bddapron.Env.typdef ] as 'd, 'e)
            Bddapron.Env.O.t ->
            ('a, ('a, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'b Bddapron.Bdddomain0.t ->
            'a Bddapron.Expr0.Bool.t -> 'b Bddapron.Bdddomain0.t
          val assign_lexpr :
            ?relational:bool ->
            ?nodependency:bool ->
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ] as 'c,
             [> 'a Bddapron.Env.typdef ] as 'd, 'e)
            Bddapron.Env.O.t ->
            ('a, ('a, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'b Bddapron.Bdddomain0.t ->
            'a list ->
            'a Bddapron.Expr0.t list ->
            'b Bddapron.Bdddomain0.t option -> 'b Bddapron.Bdddomain0.t
          val substitute_lexpr :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ] as 'c,
             [> 'a Bddapron.Env.typdef ] as 'd, 'e)
            Bddapron.Env.O.t ->
            ('a, ('a, 'c, 'd, 'e) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
            'b Bddapron.Bdddomain0.t ->
            'a list ->
            'a Bddapron.Expr0.t list ->
            'b Bddapron.Bdddomain0.t option -> 'b Bddapron.Bdddomain0.t
          val forget_list :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            ('a, [> 'a Bddapron.Env.typ ], [> 'a Bddapron.Env.typdef ], 'e)
            Bddapron.Env.O.t ->
            'b Bddapron.Bdddomain0.t -> 'a list -> 'b Bddapron.Bdddomain0.t
          val widening :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t ->
            'b Bddapron.Bdddomain0.t -> 'b Bddapron.Bdddomain0.t
          val widening_threshold :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t ->
            'b Bddapron.Bdddomain0.t ->
            Apron.Lincons0.t array -> 'b Bddapron.Bdddomain0.t
          val apply_change :
            bottom:'b Bddapron.Bdddomain0.t ->
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t ->
            Bddapron.Env.change -> 'b Bddapron.Bdddomain0.t
          val apply_permutation :
            ('a, 'b) Bddapron.Bdddomain0.man ->
            'b Bddapron.Bdddomain0.t ->
            int array option * Apron.Dim.perm option ->
            'b Bddapron.Bdddomain0.t
        end
    end
  module Domain0 :
    sig
      type ('a, 'b, 'c, 'd) man = {
        typ : string;
        man : 'c;
        canonicalize : ?apron:bool -> 'c -> 'd -> unit;
        size : 'c -> 'd -> int;
        print :
          ?print_apron:((int -> string) ->
                        Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
          'a Bddapron.Env.t -> Format.formatter -> 'd -> unit;
        bottom : 'c -> 'a Bddapron.Env.t -> 'd;
        top : 'c -> 'a Bddapron.Env.t -> 'd;
        of_apron : 'c -> 'a Bddapron.Env.t -> 'b Apron.Abstract0.t -> 'd;
        of_bddapron :
          'c ->
          'a Bddapron.Env.t ->
          ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list -> 'd;
        is_bottom : 'c -> 'd -> bool;
        is_top : 'c -> 'd -> bool;
        is_leq : 'c -> 'd -> 'd -> bool;
        is_eq : 'c -> 'd -> 'd -> bool;
        to_bddapron :
          'c -> 'd -> ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list;
        meet : 'c -> 'd -> 'd -> 'd;
        join : 'c -> 'd -> 'd -> 'd;
        meet_condition :
          'c ->
          'a Bddapron.Env.t ->
          'a Bddapron.Cond.t -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'd;
        assign_lexpr :
          ?relational:bool ->
          ?nodependency:bool ->
          'c ->
          'a Bddapron.Env.t ->
          'a Bddapron.Cond.t ->
          'd -> 'a list -> 'a Bddapron.Expr0.t list -> 'd option -> 'd;
        substitute_lexpr :
          'c ->
          'a Bddapron.Env.t ->
          'a Bddapron.Cond.t ->
          'd -> 'a list -> 'a Bddapron.Expr0.t list -> 'd option -> 'd;
        forget_list : 'c -> 'a Bddapron.Env.t -> 'd -> 'a list -> 'd;
        widening : 'c -> 'd -> 'd -> 'd;
        widening_threshold : 'c -> 'd -> 'd -> Apron.Lincons0.t array -> 'd;
        apply_change : bottom:'d -> 'c -> 'd -> Bddapron.Env.change -> 'd;
        apply_permutation :
          'c -> 'd -> int array option * Apron.Dim.perm option -> 'd;
      }
      type 'd t = 'd
      val canonicalize :
        ?apron:bool ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t -> unit
      val size :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man -> 'd Bddapron.Domain0.t -> int
      val print :
        ?print_apron:((int -> string) ->
                      Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t ->
        Format.formatter -> 'd Bddapron.Domain0.t -> unit
      val bottom :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t -> 'd Bddapron.Domain0.t
      val top :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t -> 'd Bddapron.Domain0.t
      val of_apron :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t -> 'b Apron.Abstract0.t -> 'd Bddapron.Domain0.t
      val of_bddapron :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t ->
        ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list ->
        'd Bddapron.Domain0.t
      val is_bottom :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t -> bool
      val is_top :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t -> bool
      val is_leq :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t -> 'd Bddapron.Domain0.t -> bool
      val is_eq :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t -> 'd Bddapron.Domain0.t -> bool
      val to_bddapron :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t ->
        ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list
      val meet :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t ->
        'd Bddapron.Domain0.t -> 'd Bddapron.Domain0.t
      val join :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t ->
        'd Bddapron.Domain0.t -> 'd Bddapron.Domain0.t
      val meet_condition :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'd Bddapron.Domain0.t ->
        'a Bddapron.Expr0.Bool.t -> 'd Bddapron.Domain0.t
      val assign_lexpr :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'd Bddapron.Domain0.t ->
        'a list ->
        'a Bddapron.Expr0.t list ->
        'd Bddapron.Domain0.t option -> 'd Bddapron.Domain0.t
      val substitute_lexpr :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'd Bddapron.Domain0.t ->
        'a list ->
        'a Bddapron.Expr0.t list ->
        'd Bddapron.Domain0.t option -> 'd Bddapron.Domain0.t
      val forget_list :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'a Bddapron.Env.t ->
        'd Bddapron.Domain0.t -> 'a list -> 'd Bddapron.Domain0.t
      val widening :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t ->
        'd Bddapron.Domain0.t -> 'd Bddapron.Domain0.t
      val widening_threshold :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t ->
        'd Bddapron.Domain0.t ->
        Apron.Lincons0.t array -> 'd Bddapron.Domain0.t
      val apply_change :
        bottom:'d Bddapron.Domain0.t ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t -> Bddapron.Env.change -> 'd Bddapron.Domain0.t
      val apply_permutation :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        'd Bddapron.Domain0.t ->
        int array option * Apron.Dim.perm option -> 'd Bddapron.Domain0.t
      val man_get_apron :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man -> 'b Apron.Manager.t
      type ('a, 'b) mtbdd =
          ('a, 'b, ('a, 'b) Bddapron.Mtbdddomain0.man,
           'b Bddapron.Mtbdddomain0.t)
          Bddapron.Domain0.man
      val mtbdd_of_mtbdddomain :
        ('a, 'b) Bddapron.Mtbdddomain0.man -> ('a, 'b) Bddapron.Domain0.mtbdd
      val make_mtbdd :
        ?global:bool -> 'b Apron.Manager.t -> ('a, 'b) Bddapron.Domain0.mtbdd
      val man_is_mtbdd : ('a, 'b, 'c, 'd) Bddapron.Domain0.man -> bool
      val man_of_mtbdd :
        ('a, 'b) Bddapron.Domain0.mtbdd ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man
      val man_to_mtbdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        ('a, 'b) Bddapron.Domain0.mtbdd
      val of_mtbdd :
        ('a, 'b) Bddapron.Domain0.mtbdd *
        'b Bddapron.Mtbdddomain0.t Bddapron.Domain0.t ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man * 'd Bddapron.Domain0.t
      val to_mtbdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man * 'd Bddapron.Domain0.t ->
        ('a, 'b) Bddapron.Domain0.mtbdd *
        'b Bddapron.Mtbdddomain0.t Bddapron.Domain0.t
      type ('a, 'b) bdd =
          ('a, 'b, ('a, 'b) Bddapron.Bdddomain0.man,
           'b Bddapron.Bdddomain0.t)
          Bddapron.Domain0.man
      val bdd_of_bdddomain :
        ('a, 'b) Bddapron.Bdddomain0.man -> ('a, 'b) Bddapron.Domain0.bdd
      val make_bdd : 'b Apron.Manager.t -> ('a, 'b) Bddapron.Domain0.bdd
      val man_is_bdd : ('a, 'b, 'c, 'd) Bddapron.Domain0.man -> bool
      val man_of_bdd :
        ('a, 'b) Bddapron.Domain0.bdd ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man
      val man_to_bdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
        ('a, 'b) Bddapron.Domain0.bdd
      val of_bdd :
        ('a, 'b) Bddapron.Domain0.bdd *
        'b Bddapron.Bdddomain0.t Bddapron.Domain0.t ->
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man * 'd Bddapron.Domain0.t
      val to_bdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain0.man * 'd Bddapron.Domain0.t ->
        ('a, 'b) Bddapron.Domain0.bdd *
        'b Bddapron.Bdddomain0.t Bddapron.Domain0.t
    end
  module Domainlevel1 :
    sig
      module type Level0 =
        sig
          type ('a, 'b) man
          type 'b t
          val size :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t -> int
          val print :
            ?print_apron:((int -> string) ->
                          Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
            'a Bddapron.Env.t ->
            Format.formatter -> 'b Bddapron.Domainlevel1.Level0.t -> unit
          val bottom :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t -> 'b Bddapron.Domainlevel1.Level0.t
          val top :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t -> 'b Bddapron.Domainlevel1.Level0.t
          val of_apron :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t ->
            'b Apron.Abstract0.t -> 'b Bddapron.Domainlevel1.Level0.t
          val of_bddapron :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t ->
            ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list ->
            'b Bddapron.Domainlevel1.Level0.t
          val is_bottom :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t -> bool
          val is_top :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t -> bool
          val is_leq :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t -> bool
          val is_eq :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t -> bool
          val to_bddapron :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            ('a Bddapron.Expr0.Bool.t * 'b Apron.Abstract0.t) list
          val meet :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t
          val join :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t
          val meet_condition :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'a Bddapron.Expr0.Bool.t -> 'b Bddapron.Domainlevel1.Level0.t
          val assign_lexpr :
            ?relational:bool ->
            ?nodependency:bool ->
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'a list ->
            'a Bddapron.Expr0.t list ->
            'b Bddapron.Domainlevel1.Level0.t option ->
            'b Bddapron.Domainlevel1.Level0.t
          val substitute_lexpr :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'a list ->
            'a Bddapron.Expr0.t list ->
            'b Bddapron.Domainlevel1.Level0.t option ->
            'b Bddapron.Domainlevel1.Level0.t
          val forget_list :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'a Bddapron.Env.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'a list -> 'b Bddapron.Domainlevel1.Level0.t
          val widening :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t
          val widening_threshold :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            'b Bddapron.Domainlevel1.Level0.t ->
            Apron.Lincons0.t array -> 'b Bddapron.Domainlevel1.Level0.t
          val apply_change :
            bottom:'b Bddapron.Domainlevel1.Level0.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            Bddapron.Env.change -> 'b Bddapron.Domainlevel1.Level0.t
          val apply_permutation :
            ('a, 'b) Bddapron.Domainlevel1.Level0.man ->
            'b Bddapron.Domainlevel1.Level0.t ->
            int array option * Apron.Dim.perm option ->
            'b Bddapron.Domainlevel1.Level0.t
        end
      module type Level1 =
        sig
          type ('a, 'b) man
          type 'b t0
          type ('a, 'b) t =
              ('a Bddapron.Env.t, 'b Bddapron.Domainlevel1.Level1.t0)
              Bddapron.Env.value
          val get_env :
            ('a, 'b) Bddapron.Domainlevel1.Level1.t -> 'a Bddapron.Env.t
          val to_level0 :
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'b Bddapron.Domainlevel1.Level1.t0
          val of_level0 :
            'a Bddapron.Env.t ->
            'b Bddapron.Domainlevel1.Level1.t0 ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val size :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t -> int
          val print :
            ?print_apron:((int -> string) ->
                          Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
            Format.formatter ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t -> unit
          val bottom :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            'a Bddapron.Env.t -> ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val top :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            'a Bddapron.Env.t -> ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val of_apron :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            'a Bddapron.Env.t ->
            'b Apron.Abstract1.t -> ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val of_bddapron :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            'a Bddapron.Env.t ->
            ('a Bddapron.Expr1.Bool.t * 'b Apron.Abstract1.t) list ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val is_bottom :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t -> bool
          val is_top :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t -> bool
          val is_leq :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t -> bool
          val is_eq :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t -> bool
          val to_bddapron :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a Bddapron.Expr1.Bool.t * 'b Apron.Abstract1.t) list
          val meet :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val join :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val meet_condition :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            'a Bddapron.Cond.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a Bddapron.Expr1.Bool.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val meet_condition2 :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a Bddapron.Expr2.Bool.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val assign_lexpr :
            ?relational:bool ->
            ?nodependency:bool ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            'a Bddapron.Cond.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a list ->
            'a Bddapron.Expr1.t list ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t option ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val assign_listexpr2 :
            ?relational:bool ->
            ?nodependency:bool ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a list ->
            'a Bddapron.Expr2.List.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t option ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val substitute_lexpr :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            'a Bddapron.Cond.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a list ->
            'a Bddapron.Expr1.t list ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t option ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val substitute_listexpr2 :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a list ->
            'a Bddapron.Expr2.List.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t option ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val forget_list :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a list -> ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val widening :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val widening_threshold :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            Apron.Lincons1.earray -> ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val change_environment :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            'a Bddapron.Env.t -> ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val rename :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a * 'a) list -> ('a, 'b) Bddapron.Domainlevel1.Level1.t
          val unify :
            ('a, 'b) Bddapron.Domainlevel1.Level1.man ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t ->
            ('a, 'b) Bddapron.Domainlevel1.Level1.t
        end
      module Make :
        functor (Level0 : Level0) ->
          sig
            type ('a, 'b) man = ('a, 'b) Level0.man
            type 'b t0 = 'b Level0.t
            type ('a, 'b) t = ('a Env.t, 'b t0) Env.value
            val get_env : ('a, 'b) t -> 'a Env.t
            val to_level0 : ('a, 'b) t -> 'b t0
            val of_level0 : 'a Env.t -> 'b t0 -> ('a, 'b) t
            val size : ('a, 'b) man -> ('a, 'b) t -> int
            val print :
              ?print_apron:((int -> string) ->
                            Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
              Format.formatter -> ('a, 'b) t -> unit
            val bottom : ('a, 'b) man -> 'a Env.t -> ('a, 'b) t
            val top : ('a, 'b) man -> 'a Env.t -> ('a, 'b) t
            val of_apron :
              ('a, 'b) man -> 'a Env.t -> 'b Apron.Abstract1.t -> ('a, 'b) t
            val of_bddapron :
              ('a, 'b) man ->
              'a Env.t ->
              ('a Expr1.Bool.t * 'b Apron.Abstract1.t) list -> ('a, 'b) t
            val is_bottom : ('a, 'b) man -> ('a, 'b) t -> bool
            val is_top : ('a, 'b) man -> ('a, 'b) t -> bool
            val is_leq : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> bool
            val is_eq : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> bool
            val to_bddapron :
              ('a, 'b) man ->
              ('a, 'b) t -> ('a Expr1.Bool.t * 'b Apron.Abstract1.t) list
            val meet : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
            val join : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
            val meet_condition :
              ('a, 'b) man ->
              'a Cond.t -> ('a, 'b) t -> 'a Expr1.Bool.t -> ('a, 'b) t
            val meet_condition2 :
              ('a, 'b) man -> ('a, 'b) t -> 'a Expr2.Bool.t -> ('a, 'b) t
            val assign_lexpr :
              ?relational:bool ->
              ?nodependency:bool ->
              ('a, 'b) man ->
              'a Cond.t ->
              ('a, 'b) t ->
              'a list -> 'a Expr1.t list -> ('a, 'b) t option -> ('a, 'b) t
            val assign_listexpr2 :
              ?relational:bool ->
              ?nodependency:bool ->
              ('a, 'b) man ->
              ('a, 'b) t ->
              'a list -> 'a Expr2.List.t -> ('a, 'b) t option -> ('a, 'b) t
            val substitute_lexpr :
              ('a, 'b) man ->
              'a Cond.t ->
              ('a, 'b) t ->
              'a list -> 'a Expr1.t list -> ('a, 'b) t option -> ('a, 'b) t
            val substitute_listexpr2 :
              ('a, 'b) man ->
              ('a, 'b) t ->
              'a list -> 'a Expr2.List.t -> ('a, 'b) t option -> ('a, 'b) t
            val forget_list :
              ('a, 'b) man -> ('a, 'b) t -> 'a list -> ('a, 'b) t
            val widening :
              ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
            val widening_threshold :
              ('a, 'b) man ->
              ('a, 'b) t -> ('a, 'b) t -> Apron.Lincons1.earray -> ('a, 'b) t
            val change_environment :
              ('a, 'b) man -> ('a, 'b) t -> 'a Env.t -> ('a, 'b) t
            val rename :
              ('a, 'b) man -> ('a, 'b) t -> ('a * 'a) list -> ('a, 'b) t
            val unify :
              ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
          end
    end
  module Mtbdddomain1 :
    sig
      val make_man :
        ?global:bool ->
        'b Apron.Manager.t -> ('a, 'b) Bddapron.Mtbdddomain0.man
      type ('a, 'b) man = ('a, 'b) Mtbdddomain0.man
      type 'b t0 = 'b Mtbdddomain0.t
      type ('a, 'b) t = ('a Env.t, 'b t0) Env.value
      val get_env : ('a, 'b) t -> 'a Env.t
      val to_level0 : ('a, 'b) t -> 'b t0
      val of_level0 : 'a Env.t -> 'b t0 -> ('a, 'b) t
      val size : ('a, 'b) man -> ('a, 'b) t -> int
      val print :
        ?print_apron:((int -> string) ->
                      Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
        Format.formatter -> ('a, 'b) t -> unit
      val bottom : ('a, 'b) man -> 'a Env.t -> ('a, 'b) t
      val top : ('a, 'b) man -> 'a Env.t -> ('a, 'b) t
      val of_apron :
        ('a, 'b) man -> 'a Env.t -> 'b Apron.Abstract1.t -> ('a, 'b) t
      val of_bddapron :
        ('a, 'b) man ->
        'a Env.t ->
        ('a Expr1.Bool.t * 'b Apron.Abstract1.t) list -> ('a, 'b) t
      val is_bottom : ('a, 'b) man -> ('a, 'b) t -> bool
      val is_top : ('a, 'b) man -> ('a, 'b) t -> bool
      val is_leq : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> bool
      val is_eq : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> bool
      val to_bddapron :
        ('a, 'b) man ->
        ('a, 'b) t -> ('a Expr1.Bool.t * 'b Apron.Abstract1.t) list
      val meet : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val join : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val meet_condition :
        ('a, 'b) man ->
        'a Cond.t -> ('a, 'b) t -> 'a Expr1.Bool.t -> ('a, 'b) t
      val meet_condition2 :
        ('a, 'b) man -> ('a, 'b) t -> 'a Expr2.Bool.t -> ('a, 'b) t
      val assign_lexpr :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b) man ->
        'a Cond.t ->
        ('a, 'b) t ->
        'a list -> 'a Expr1.t list -> ('a, 'b) t option -> ('a, 'b) t
      val assign_listexpr2 :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b) man ->
        ('a, 'b) t ->
        'a list -> 'a Expr2.List.t -> ('a, 'b) t option -> ('a, 'b) t
      val substitute_lexpr :
        ('a, 'b) man ->
        'a Cond.t ->
        ('a, 'b) t ->
        'a list -> 'a Expr1.t list -> ('a, 'b) t option -> ('a, 'b) t
      val substitute_listexpr2 :
        ('a, 'b) man ->
        ('a, 'b) t ->
        'a list -> 'a Expr2.List.t -> ('a, 'b) t option -> ('a, 'b) t
      val forget_list : ('a, 'b) man -> ('a, 'b) t -> 'a list -> ('a, 'b) t
      val widening : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val widening_threshold :
        ('a, 'b) man ->
        ('a, 'b) t -> ('a, 'b) t -> Apron.Lincons1.earray -> ('a, 'b) t
      val change_environment :
        ('a, 'b) man -> ('a, 'b) t -> 'a Env.t -> ('a, 'b) t
      val rename : ('a, 'b) man -> ('a, 'b) t -> ('a * 'a) list -> ('a, 'b) t
      val unify : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
    end
  module Bdddomain1 :
    sig
      type ('a, 'b) man = ('a, 'b) Bdddomain0.man
      type 'b t0 = 'b Bdddomain0.t
      type ('a, 'b) t = ('a Env.t, 'b t0) Env.value
      val get_env : ('a, 'b) t -> 'a Env.t
      val to_level0 : ('a, 'b) t -> 'b t0
      val of_level0 : 'a Env.t -> 'b t0 -> ('a, 'b) t
      val size : ('a, 'b) man -> ('a, 'b) t -> int
      val print :
        ?print_apron:((int -> string) ->
                      Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
        Format.formatter -> ('a, 'b) t -> unit
      val bottom : ('a, 'b) man -> 'a Env.t -> ('a, 'b) t
      val top : ('a, 'b) man -> 'a Env.t -> ('a, 'b) t
      val of_apron :
        ('a, 'b) man -> 'a Env.t -> 'b Apron.Abstract1.t -> ('a, 'b) t
      val of_bddapron :
        ('a, 'b) man ->
        'a Env.t ->
        ('a Expr1.Bool.t * 'b Apron.Abstract1.t) list -> ('a, 'b) t
      val is_bottom : ('a, 'b) man -> ('a, 'b) t -> bool
      val is_top : ('a, 'b) man -> ('a, 'b) t -> bool
      val is_leq : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> bool
      val is_eq : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> bool
      val to_bddapron :
        ('a, 'b) man ->
        ('a, 'b) t -> ('a Expr1.Bool.t * 'b Apron.Abstract1.t) list
      val meet : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val join : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val meet_condition :
        ('a, 'b) man ->
        'a Cond.t -> ('a, 'b) t -> 'a Expr1.Bool.t -> ('a, 'b) t
      val meet_condition2 :
        ('a, 'b) man -> ('a, 'b) t -> 'a Expr2.Bool.t -> ('a, 'b) t
      val assign_lexpr :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b) man ->
        'a Cond.t ->
        ('a, 'b) t ->
        'a list -> 'a Expr1.t list -> ('a, 'b) t option -> ('a, 'b) t
      val assign_listexpr2 :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b) man ->
        ('a, 'b) t ->
        'a list -> 'a Expr2.List.t -> ('a, 'b) t option -> ('a, 'b) t
      val substitute_lexpr :
        ('a, 'b) man ->
        'a Cond.t ->
        ('a, 'b) t ->
        'a list -> 'a Expr1.t list -> ('a, 'b) t option -> ('a, 'b) t
      val substitute_listexpr2 :
        ('a, 'b) man ->
        ('a, 'b) t ->
        'a list -> 'a Expr2.List.t -> ('a, 'b) t option -> ('a, 'b) t
      val forget_list : ('a, 'b) man -> ('a, 'b) t -> 'a list -> ('a, 'b) t
      val widening : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val widening_threshold :
        ('a, 'b) man ->
        ('a, 'b) t -> ('a, 'b) t -> Apron.Lincons1.earray -> ('a, 'b) t
      val change_environment :
        ('a, 'b) man -> ('a, 'b) t -> 'a Env.t -> ('a, 'b) t
      val rename : ('a, 'b) man -> ('a, 'b) t -> ('a * 'a) list -> ('a, 'b) t
      val unify : ('a, 'b) man -> ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val make_man : 'b Apron.Manager.t -> ('a, 'b) man
      val canonicalize :
        ?apron:bool ->
        ?unique:bool -> ?disjoint:bool -> ('a, 'b) man -> ('a, 'b) t -> unit
    end
  module Domain1 :
    sig
      type ('a, 'b, 'c, 'd) man = ('a, 'b, 'c, 'd) Bddapron.Domain0.man
      type ('a, 'b) mtbdd =
          ('a, 'b, ('a, 'b) Bddapron.Mtbdddomain0.man,
           'b Bddapron.Mtbdddomain0.t)
          Bddapron.Domain1.man
      type ('a, 'b) bdd =
          ('a, 'b, ('a, 'b) Bddapron.Bdddomain0.man,
           'b Bddapron.Bdddomain0.t)
          Bddapron.Domain1.man
      type ('a, 'd) t = ('a Bddapron.Env.t, 'd) Bddapron.Env.value
      val canonicalize :
        ?apron:bool ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t -> unit
      val print :
        ?print_apron:((int -> string) ->
                      Format.formatter -> 'b Apron.Abstract0.t -> unit) ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        Format.formatter -> ('a, 'd) Bddapron.Domain1.t -> unit
      val get_env : ('a, 'd) Bddapron.Domain1.t -> 'a Bddapron.Env.t
      val to_level0 : ('a, 'd) Bddapron.Domain1.t -> 'd
      val of_level0 : 'a Bddapron.Env.t -> 'd -> ('a, 'd) Bddapron.Domain1.t
      val size :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t -> int
      val bottom :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        'a Bddapron.Env.t -> ('a, 'd) Bddapron.Domain1.t
      val top :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        'a Bddapron.Env.t -> ('a, 'd) Bddapron.Domain1.t
      val of_apron :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        'a Bddapron.Env.t ->
        'b Apron.Abstract1.t -> ('a, 'd) Bddapron.Domain1.t
      val of_bddapron :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        'a Bddapron.Env.t ->
        ('a Bddapron.Expr1.Bool.t * 'b Apron.Abstract1.t) list ->
        ('a, 'd) Bddapron.Domain1.t
      val is_bottom :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t -> bool
      val is_top :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t -> bool
      val is_leq :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t -> ('a, 'd) Bddapron.Domain1.t -> bool
      val is_eq :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t -> ('a, 'd) Bddapron.Domain1.t -> bool
      val to_bddapron :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        ('a Bddapron.Expr1.Bool.t * 'b Apron.Abstract1.t) list
      val meet :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        ('a, 'd) Bddapron.Domain1.t -> ('a, 'd) Bddapron.Domain1.t
      val join :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        ('a, 'd) Bddapron.Domain1.t -> ('a, 'd) Bddapron.Domain1.t
      val meet_condition :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        'a Bddapron.Cond.t ->
        ('a, 'd) Bddapron.Domain1.t ->
        'a Bddapron.Expr1.Bool.t -> ('a, 'd) Bddapron.Domain1.t
      val meet_condition2 :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        'a Bddapron.Expr2.Bool.t -> ('a, 'd) Bddapron.Domain1.t
      val assign_lexpr :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        'a Bddapron.Cond.t ->
        ('a, 'd) Bddapron.Domain1.t ->
        'a list ->
        'a Bddapron.Expr1.t list ->
        ('a, 'd) Bddapron.Domain1.t option -> ('a, 'd) Bddapron.Domain1.t
      val assign_listexpr2 :
        ?relational:bool ->
        ?nodependency:bool ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        'a list ->
        'a Bddapron.Expr2.List.t ->
        ('a, 'd) Bddapron.Domain1.t option -> ('a, 'd) Bddapron.Domain1.t
      val substitute_lexpr :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        'a Bddapron.Cond.t ->
        ('a, 'd) Bddapron.Domain1.t ->
        'a list ->
        'a Bddapron.Expr1.t list ->
        ('a, 'd) Bddapron.Domain1.t option -> ('a, 'd) Bddapron.Domain1.t
      val substitute_listexpr2 :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        'a list ->
        'a Bddapron.Expr2.List.t ->
        ('a, 'd) Bddapron.Domain1.t option -> ('a, 'd) Bddapron.Domain1.t
      val forget_list :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t -> 'a list -> ('a, 'd) Bddapron.Domain1.t
      val widening :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        ('a, 'd) Bddapron.Domain1.t -> ('a, 'd) Bddapron.Domain1.t
      val widening_threshold :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        ('a, 'd) Bddapron.Domain1.t ->
        Apron.Lincons1.earray -> ('a, 'd) Bddapron.Domain1.t
      val change_environment :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        'a Bddapron.Env.t -> ('a, 'd) Bddapron.Domain1.t
      val unify :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        ('a, 'd) Bddapron.Domain1.t -> ('a, 'd) Bddapron.Domain1.t
      val rename :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'd) Bddapron.Domain1.t ->
        ('a * 'a) list -> ('a, 'd) Bddapron.Domain1.t
      val man_get_apron :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man -> 'b Apron.Manager.t
      val mtbdd_of_mtbdddomain :
        ('a, 'b) Bddapron.Mtbdddomain0.man -> ('a, 'b) Bddapron.Domain1.mtbdd
      val make_mtbdd :
        ?global:bool -> 'b Apron.Manager.t -> ('a, 'b) Bddapron.Domain1.mtbdd
      val man_is_mtbdd : ('a, 'b, 'c, 'd) Bddapron.Domain1.man -> bool
      val man_of_mtbdd :
        ('a, 'b) Bddapron.Domain1.mtbdd ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man
      val man_to_mtbdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'b) Bddapron.Domain1.mtbdd
      val of_mtbdd :
        ('a, 'b) Bddapron.Domain1.mtbdd *
        ('a, 'b Bddapron.Mtbdddomain0.t) Bddapron.Domain1.t ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man * ('a, 'd) Bddapron.Domain1.t
      val to_mtbdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man * ('a, 'd) Bddapron.Domain1.t ->
        ('a, 'b) Bddapron.Domain1.mtbdd *
        ('a, 'b Bddapron.Mtbdddomain0.t) Bddapron.Domain1.t
      val bdd_of_bdddomain :
        ('a, 'b) Bddapron.Bdddomain0.man -> ('a, 'b) Bddapron.Domain1.bdd
      val make_bdd : 'b Apron.Manager.t -> ('a, 'b) Bddapron.Domain1.bdd
      val man_is_bdd : ('a, 'b, 'c, 'd) Bddapron.Domain1.man -> bool
      val man_of_bdd :
        ('a, 'b) Bddapron.Domain1.bdd ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man
      val man_to_bdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man ->
        ('a, 'b) Bddapron.Domain1.bdd
      val of_bdd :
        ('a, 'b) Bddapron.Domain1.bdd *
        ('a, 'b Bddapron.Bdddomain0.t) Bddapron.Domain1.t ->
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man * ('a, 'd) Bddapron.Domain1.t
      val to_bdd :
        ('a, 'b, 'c, 'd) Bddapron.Domain1.man * ('a, 'd) Bddapron.Domain1.t ->
        ('a, 'b) Bddapron.Domain1.bdd *
        ('a, 'b Bddapron.Bdddomain0.t) Bddapron.Domain1.t
    end
  module Formula :
    sig
      module O :
        sig
          module Expr0 :
            sig
              module Bool :
                sig
                  val to_lconjunction :
                    ('a, [> 'a Bddapron.Env.typ ] as 'b,
                     [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                    Bddapron.Env.O.t ->
                    ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                    'f Bddapron.Expr0.Bool.t ->
                    ('f Bddapron.Expr0.Bool.t * 'f Bddapron.Expr0.Bool.t)
                    list
                  val forget :
                    ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
                    ('e, [> 'e Bddapron.Env.typ ] as 'f,
                     [> 'e Bddapron.Env.typdef ] as 'g, 'h)
                    Bddapron.Env.O.t ->
                    ('e, ('e, 'f, 'g, 'h) Bddapron.Env.O.t) Bddapron.Cond.O.t ->
                    'j Bddapron.Expr0.Bool.t ->
                    'e list -> 'j Bddapron.Expr0.Bool.t
                end
            end
          module Expr1 :
            sig
              module Bool :
                sig
                  val to_lconjunction :
                    ('a,
                     ('a, [> 'a Bddapron.Env.typ ] as 'b,
                      [> 'a Bddapron.Env.typdef ] as 'c, 'd)
                     Bddapron.Env.O.t)
                    Bddapron.Cond.O.t ->
                    ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                    Bddapron.Expr1.O.Bool.t ->
                    (('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                     Bddapron.Expr1.O.Bool.t *
                     ('a, ('a, 'b, 'c, 'd) Bddapron.Env.O.t)
                     Bddapron.Expr1.O.Bool.t)
                    list
                  val forget :
                    ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
                    ('e,
                     ('e, [> 'e Bddapron.Env.typ ] as 'f,
                      [> 'e Bddapron.Env.typdef ] as 'g, 'h)
                     Bddapron.Env.O.t)
                    Bddapron.Cond.O.t ->
                    ('e, ('e, 'f, 'g, 'h) Bddapron.Env.O.t)
                    Bddapron.Expr1.O.Bool.t ->
                    'e list ->
                    ('e, ('e, 'f, 'g, 'h) Bddapron.Env.O.t)
                    Bddapron.Expr1.O.Bool.t
                end
            end
        end
      module Expr0 :
        sig
          module Bool :
            sig
              val to_lconjunction :
                'a Bddapron.Env.t ->
                'a Bddapron.Cond.t ->
                'a Bddapron.Expr0.Bool.t ->
                ('a Bddapron.Expr0.Bool.t * 'a Bddapron.Expr0.Bool.t) list
              val forget :
                ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
                'e Bddapron.Env.t ->
                'e Bddapron.Cond.t ->
                'e Bddapron.Expr0.Bool.t ->
                'e list -> 'e Bddapron.Expr0.Bool.t
            end
        end
      module Expr1 :
        sig
          module Bool :
            sig
              val to_lconjunction :
                'a Bddapron.Cond.t ->
                'a Bddapron.Expr1.Bool.t ->
                ('a Bddapron.Expr1.Bool.t * 'a Bddapron.Expr1.Bool.t) list
              val forget :
                ('a, 'b, 'c, 'd) Bddapron.Domain0.man ->
                'e Bddapron.Cond.t ->
                'e Bddapron.Expr1.Bool.t ->
                'e list -> 'e Bddapron.Expr1.Bool.t
            end
        end
    end
  module Policy :
    sig
      val apron_policy_print :
        'a Apron.Policy.man ->
        'b Bddapron.Env.t -> Format.formatter -> 'a Apron.Policy.t -> unit
      module Dnf :
        sig type 'a t = 'a Bddapron.Cond.cond Bdd.Normalform.dnf end
      module DDDnf :
        sig
          type 'a t = 'a Bddapron.Policy.Dnf.t Cudd.Mtbdd.t
          type 'a table = 'a Bddapron.Policy.Dnf.t Cudd.Mtbdd.table
        end
      module DPolicy :
        sig
          type 'a t = {
            hash : int;
            dpolicy : 'a Apron.Policy.t Bdd.Normalform.disjunction;
          }
          type 'a table = 'a Bddapron.Policy.DPolicy.t Cudd.Mtbdd.table
        end
      module PMtbdddomain0 :
        sig
          type ('a, 'b) man = {
            man : ('a, 'b) Bddapron.Mtbdddomain0.man;
            papron : 'b Apron.Policy.man;
            ptable : 'b Bddapron.Policy.DPolicy.table;
            betable : 'a Bddapron.Policy.DDDnf.table;
            symbol : 'a Bddapron.Env.symbol;
          }
          type 'a t = 'a Bddapron.Policy.DPolicy.t Cudd.Mtbdd.t
        end
      module PDomain0 :
        sig
          type ('a, 'b, 'c, 'd, 'e, 'f) man = {
            man : ('a, 'b, 'c, 'd) Bddapron.Domain0.man;
            pman : 'e;
            print :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t -> Format.formatter -> 'f -> unit;
            meet_condition_apply :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t ->
              'f -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'd;
            meet_condition_improve :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t ->
              'f option -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'f;
          }
        end
      module Domain1 :
        sig
          type ('a, 'b, 'c, 'd, 'e, 'f) man =
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.PDomain0.man = {
            man : ('a, 'b, 'c, 'd) Bddapron.Domain0.man;
            pman : 'e;
            print :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t -> Format.formatter -> 'f -> unit;
            meet_condition_apply :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t ->
              'f -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'd;
            meet_condition_improve :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t ->
              'f option -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'f;
          }
          type ('a, 'b) mtbdd =
              ('a, 'b, ('a, 'b) Bddapron.Mtbdddomain0.man,
               'b Bddapron.Mtbdddomain0.t,
               ('a, 'b) Bddapron.Policy.PMtbdddomain0.man,
               'b Bddapron.Policy.PMtbdddomain0.t)
              Bddapron.Policy.Domain1.man
          val manager_get_manager :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain1.man ->
            ('a, 'b, 'c, 'd) Bddapron.Domain0.man
          val print :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain1.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> Format.formatter -> 'f -> unit
          val meet_condition_apply :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain1.man ->
            'a Bddapron.Cond.t ->
            'f ->
            ('a, 'd) Bddapron.Domain1.t ->
            'f Bddapron.Expr1.Bool.t -> ('a, 'd) Bddapron.Domain1.t
          val meet_condition_improve :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain1.man ->
            'a Bddapron.Cond.t ->
            'f option ->
            ('a, 'd) Bddapron.Domain1.t -> 'f Bddapron.Expr1.Bool.t -> 'f
          val meet_condition2_apply :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain1.man ->
            'f ->
            ('a, 'd) Bddapron.Domain1.t ->
            'a Bddapron.Expr2.Bool.t -> ('a, 'd) Bddapron.Domain1.t
          val meet_condition2_improve :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain1.man ->
            'f option ->
            ('a, 'd) Bddapron.Domain1.t -> 'a Bddapron.Expr2.Bool.t -> 'f
        end
      module Domain0 :
        sig
          type ('a, 'b, 'c, 'd, 'e, 'f) man =
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.PDomain0.man = {
            man : ('a, 'b, 'c, 'd) Bddapron.Domain0.man;
            pman : 'e;
            print :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t -> Format.formatter -> 'f -> unit;
            meet_condition_apply :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t ->
              'f -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'd;
            meet_condition_improve :
              'e ->
              'a Bddapron.Env.t ->
              'a Bddapron.Cond.t ->
              'f option -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'f;
          }
          type ('a, 'b) mtbdd =
              ('a, 'b, ('a, 'b) Bddapron.Mtbdddomain0.man,
               'b Bddapron.Mtbdddomain0.t,
               ('a, 'b) Bddapron.Policy.PMtbdddomain0.man,
               'b Bddapron.Policy.PMtbdddomain0.t)
              Bddapron.Policy.Domain0.man
          val manager_get_manager :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain0.man ->
            ('a, 'b, 'c, 'd) Bddapron.Domain0.man
          val print :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> Format.formatter -> 'f -> unit
          val meet_condition_apply :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t -> 'f -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'd
          val meet_condition_improve :
            ('a, 'b, 'c, 'd, 'e, 'f) Bddapron.Policy.Domain0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'f option -> 'd -> 'a Bddapron.Expr0.Bool.t -> 'f
          val make_mtbdd :
            ?global:bool ->
            symbol:'a Bddapron.Env.symbol ->
            'b Apron.Policy.man -> ('a, 'b) Bddapron.Policy.Domain0.mtbdd
        end
      module Mtbdddomain0 :
        sig
          type ('a, 'b) man =
            ('a, 'b) Bddapron.Policy.PMtbdddomain0.man = {
            man : ('a, 'b) Bddapron.Mtbdddomain0.man;
            papron : 'b Apron.Policy.man;
            ptable : 'b Bddapron.Policy.DPolicy.table;
            betable : 'a Bddapron.Policy.DDDnf.table;
            symbol : 'a Bddapron.Env.symbol;
          }
          type 'a t = 'a Bddapron.Policy.PMtbdddomain0.t
          val manager_get_manager :
            ('a, 'b) Bddapron.Policy.Mtbdddomain0.man ->
            ('a, 'b) Bddapron.Mtbdddomain0.man
          val make_man :
            ?global:bool ->
            symbol:'a Bddapron.Env.symbol ->
            'b Apron.Policy.man -> ('a, 'b) Bddapron.Policy.Mtbdddomain0.man
          val equal :
            'a ->
            'b Bddapron.Policy.Mtbdddomain0.t ->
            'b Bddapron.Policy.Mtbdddomain0.t -> bool
          val print :
            ('a, 'b) Bddapron.Policy.Mtbdddomain0.man ->
            'c Bddapron.Env.t ->
            'c Bddapron.Cond.t ->
            Format.formatter -> 'b Bddapron.Policy.Mtbdddomain0.t -> unit
          val meet_condition_apply :
            ('a, 'b) Bddapron.Policy.Mtbdddomain0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'b Bddapron.Policy.Mtbdddomain0.t ->
            'b Bddapron.Mtbdddomain0.t ->
            'a Bddapron.Expr0.Bool.t -> 'b Bddapron.Mtbdddomain0.t
          val meet_condition_improve :
            ('a, 'b) Bddapron.Policy.Mtbdddomain0.man ->
            'a Bddapron.Env.t ->
            'a Bddapron.Cond.t ->
            'b Bddapron.Policy.Mtbdddomain0.t option ->
            'b Bddapron.Mtbdddomain0.t ->
            'a Bddapron.Expr0.Bool.t -> 'b Bddapron.Policy.Mtbdddomain0.t
        end
    end
  module Syntax :
    sig
      type cst =
          [ `Apron of Apron.Coeff.t
          | `Bint of (bool * int) * int
          | `Bool of bool ]
      type unop =
          [ `Apron of
              Apron.Texpr1.unop * Apron.Texpr1.typ * Apron.Texpr1.round
          | `Not ]
      type bbinop = [ `And | `EQ | `GEQ | `GT | `LEQ | `LT | `NEQ | `Or ]
      type binop =
          [ `Apron of
              Apron.Texpr1.binop * Apron.Texpr1.typ * Apron.Texpr1.round
          | `Bool of Bddapron.Syntax.bbinop ]
      type 'a expr =
          [ `Binop of
              Bddapron.Syntax.binop * 'a Bddapron.Syntax.expr *
              'a Bddapron.Syntax.expr
          | `Cst of Bddapron.Syntax.cst
          | `If of
              'a Bddapron.Syntax.expr * 'a Bddapron.Syntax.expr *
              'a Bddapron.Syntax.expr
          | `In of 'a Bddapron.Syntax.expr * 'a Bddapron.Syntax.expr list
          | `Ref of 'a
          | `Unop of Bddapron.Syntax.unop * 'a Bddapron.Syntax.expr ]
      val print_cst : Format.formatter -> Bddapron.Syntax.cst -> unit
      val print_unop : Format.formatter -> Bddapron.Syntax.unop -> unit
      val print_bbinop : Format.formatter -> Bddapron.Syntax.bbinop -> unit
      val print_binop : Format.formatter -> Bddapron.Syntax.binop -> unit
      val print_expr :
        (Format.formatter -> 'a -> unit) ->
        Format.formatter -> 'a Bddapron.Syntax.expr -> unit
      exception Error of string
      val to_expr0 :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t -> 'a Bddapron.Syntax.expr -> 'a Bddapron.Expr0.t
      val to_expr1 :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t -> 'a Bddapron.Syntax.expr -> 'a Bddapron.Expr1.t
      val to_listexpr1 :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Syntax.expr list -> 'a Bddapron.Expr1.List.t
      val to_listexpr2 :
        ?normalize:bool ->
        ?reduce:bool ->
        ?careset:bool ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Syntax.expr list -> 'a Bddapron.Expr2.List.t
      val to_boolexpr2 :
        ?normalize:bool ->
        ?reduce:bool ->
        ?careset:bool ->
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        'a Bddapron.Syntax.expr -> 'a Bddapron.Expr2.Bool.t
      val error : ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
      val is_zero : 'a Bddapron.Syntax.expr -> bool
      val precedence_of_unop : Bddapron.Syntax.unop -> int
      val precedence_of_binop : Bddapron.Syntax.binop -> int
      val precedence_of_expr : 'a Bddapron.Syntax.expr -> int
      val cst_to_expr0 :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        [< Bddapron.Syntax.cst ] -> 'a Bddapron.Expr0.expr
      val apply_bbinop :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        Bddapron.Syntax.bbinop ->
        'a Bddapron.Expr0.expr ->
        'a Bddapron.Expr0.expr -> 'a Bddapron.Expr0.Bool.t
      val apply_binop :
        'a Bddapron.Env.t ->
        'a Bddapron.Cond.t ->
        Bddapron.Syntax.binop ->
        'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t -> 'a Bddapron.Expr0.t
    end
  module Yacc :
    sig
      type token =
          TK_LBRACKET
        | TK_RBRACKET
        | TK_SEMICOLON
        | TK_COLON
        | TK_LPAR
        | TK_RPAR
        | TK_LBRACE
        | TK_RBRACE
        | TK_BOOL
        | TK_UINT
        | TK_SINT
        | TK_INT
        | TK_REAL
        | TK_IN
        | TK_COMMA
        | TK_TYPEDEF
        | TK_ENUM
        | TK_IF
        | TK_THEN
        | TK_ELSE
        | TK_VERTEX
        | TK_RAY
        | TK_LINE
        | TK_MOD
        | TK_RAYMOD
        | TK_LINEMOD
        | TK_MUL of (Apron.Texpr1.typ * Apron.Texpr1.round)
        | TK_ADD of (Apron.Texpr1.typ * Apron.Texpr1.round)
        | TK_SUB of (Apron.Texpr1.typ * Apron.Texpr1.round)
        | TK_DIV of (Apron.Texpr1.typ * Apron.Texpr1.round)
        | TK_MODULO of (Apron.Texpr1.typ * Apron.Texpr1.round)
        | TK_CAST of (Apron.Texpr1.typ * Apron.Texpr1.round)
        | TK_SQRT of (Apron.Texpr1.typ * Apron.Texpr1.round)
        | TK_MPQF of Mpqf.t
        | TK_FLOAT of float
        | TK_LEQ
        | TK_GEQ
        | TK_LT
        | TK_GT
        | TK_EQ
        | TK_NEQ
        | TK_AND
        | TK_OR
        | TK_NOT
        | TK_ID of string
        | TK_TRUE
        | TK_FALSE
        | TK_EOF
      val expr :
        (Lexing.lexbuf -> Bddapron.Yacc.token) ->
        Lexing.lexbuf -> string Bddapron.Syntax.expr
    end
  module Lex :
    sig
      exception Error of int * int
      val lex : Lexing.lexbuf -> Bddapron.Yacc.token
    end
  module Parser :
    sig
      val expr0_of_string :
        string Bddapron.Env.t ->
        string Bddapron.Cond.t -> string -> string Bddapron.Expr0.t
      val expr1_of_string :
        string Bddapron.Env.t ->
        string Bddapron.Cond.t -> string -> string Bddapron.Expr1.t
      val listexpr1_of_lstring :
        string Bddapron.Env.t ->
        string Bddapron.Cond.t -> string list -> string Bddapron.Expr1.List.t
      val listexpr2_of_lstring :
        ?normalize:bool ->
        ?reduce:bool ->
        ?careset:bool ->
        string Bddapron.Env.t ->
        string Bddapron.Cond.t -> string list -> string Bddapron.Expr2.List.t
      val boolexpr2_of_string :
        ?normalize:bool ->
        ?reduce:bool ->
        ?careset:bool ->
        string Bddapron.Env.t ->
        string Bddapron.Cond.t -> string -> string Bddapron.Expr2.Bool.t
      val expr0_of_lexbuf :
        string Bddapron.Env.t ->
        string Bddapron.Cond.t -> Lexing.lexbuf -> string Bddapron.Expr0.t
    end
end