non-deterministic calls are marked

Signed-off-by: Lev Nachmanson <levnach@hotmail.com>

src/ast/ast.cpp

@@ -2240,8 +2240,10 @@ app * ast_manager::mk_app(func_decl * decl, unsigned num_args, expr * const * ar
             r = mk_app_core(decl, args[j-1], args[j]);
             -- j;
             while (j > 0) {
+                // TODO: non-deterministic parameter evaluation
                 --j;
                 r = mk_app_core(decl, args[j], r);
+            // TODO: non-deterministic parameter evaluation
             }
         }
         else if (decl->is_left_associative()) {

src/ast/bv_decl_plugin.cpp

@@ -47,7 +47,9 @@ void bv_decl_plugin::set_manager(ast_manager * m, family_id id) {
     for (unsigned i = 1; i <= 64; i++) 
         mk_bv_sort(i);
 
+    // TODO: non-deterministic parameter evaluation
     m_bit0 = m->mk_const_decl(symbol("bit0"), get_bv_sort(1), func_decl_info(m_family_id, OP_BIT0));
+    // TODO: non-deterministic parameter evaluation
     m_bit1 = m->mk_const_decl(symbol("bit1"), get_bv_sort(1), func_decl_info(m_family_id, OP_BIT1));
     m->inc_ref(m_bit0);
     m->inc_ref(m_bit1);
@@ -509,6 +511,7 @@ func_decl * bv_decl_plugin::mk_mkbv(unsigned arity, sort * const * domain) {
     unsigned bv_size = arity;
     m_mkbv.reserve(bv_size+1);
     if (m_mkbv[bv_size] == 0) {
+        // TODO: non-deterministic parameter evaluation
         m_mkbv[bv_size] = m_manager->mk_func_decl(m_mkbv_sym, arity, domain, get_bv_sort(bv_size), func_decl_info(m_family_id, OP_MKBV));
         m_manager->inc_ref(m_mkbv[bv_size]);
     }
@@ -578,21 +581,25 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p
     case OP_CONCAT:
         if (!get_concat_size(arity, domain, r_size))
             m_manager->raise_exception("invalid concat application");
+        // TODO: non-deterministic parameter evaluation
         return m_manager->mk_func_decl(m_concat_sym, arity, domain, get_bv_sort(r_size),
                                        func_decl_info(m_family_id, k));
     case OP_SIGN_EXT:
         if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
             m_manager->raise_exception("invalid sign_extend application");
+        // TODO: non-deterministic parameter evaluation
         return m_manager->mk_func_decl(m_sign_extend_sym, arity, domain, get_bv_sort(r_size),
                                        func_decl_info(m_family_id, k, num_parameters, parameters));
     case OP_ZERO_EXT:
         if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
             m_manager->raise_exception("invalid zero_extend application");
+        // TODO: non-deterministic parameter evaluation
         return m_manager->mk_func_decl(m_zero_extend_sym, arity, domain, get_bv_sort(r_size),
                                        func_decl_info(m_family_id, k, num_parameters, parameters));
     case OP_EXTRACT:
         if (!get_extract_size(num_parameters, parameters, arity, domain, r_size))
             m_manager->raise_exception("invalid extract application");
+        // TODO: non-deterministic parameter evaluation
         return m_manager->mk_func_decl(m_extract_sym, arity, domain, get_bv_sort(r_size),
                                        func_decl_info(m_family_id, k, num_parameters, parameters));
     case OP_ROTATE_LEFT:
@@ -616,6 +623,7 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p
             m_manager->raise_exception("repeat expects one nonzero integer parameter");
         if (!get_bv_size(domain[0], bv_size))
             m_manager->raise_exception("repeat expects an argument with bit-vector sort");
+        // TODO: non-deterministic parameter evaluation
         return m_manager->mk_func_decl(m_repeat_sym, arity, domain, get_bv_sort(bv_size * parameters[0].get_int()),
                                        func_decl_info(m_family_id, k, num_parameters, parameters));
     default:

src/ast/char_decl_plugin.cpp

@@ -66,6 +66,7 @@ func_decl* char_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
             msg << "incorrect number of arguments passed. Expected one character, received " << arity;
         else {
             arith_util a(m);
+            // TODO: non-deterministic parameter evaluation
             return m.mk_func_decl(symbol("char.to_int"), arity, domain, a.mk_int(), func_decl_info(m_family_id, k, 0, nullptr));
         }
         m.raise_exception(msg.str());
@@ -79,6 +80,7 @@ func_decl* char_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
         else {
             bv_util b(m);
             unsigned sz = num_bits();
+            // TODO: non-deterministic parameter evaluation
             return m.mk_func_decl(symbol("char.to_bv"), arity, domain, b.mk_sort(sz), func_decl_info(m_family_id, k, 0, nullptr));
         }
         m.raise_exception(msg.str());

src/ast/converters/generic_model_converter.cpp

@@ -262,6 +262,7 @@ expr_ref generic_model_converter::simplify_def(entry const& e) {
         rep.apply_substitution(c, m.mk_true(),  result1);
         rep.apply_substitution(c, m.mk_false(), result2);
         th_rewriter rw(m);
+        // TODO: non-deterministic parameter evaluation
         expr_ref result(m.mk_and(m.mk_implies(result2, c), m.mk_implies(c, result1)), m);
         rw(result);
         return result;

src/ast/format.h

@@ -90,15 +90,18 @@ namespace format_ns {
     format * mk_seq1(ast_manager & m, It const & begin, It const & end, ToDoc proc, char const * header, 
                      char const * lp = "(", char const * rp = ")") {
         if (begin == end)
+            // TODO: non-deterministic parameter evaluation
             return mk_compose(m, mk_string(m, lp), mk_string(m, header), mk_string(m, rp));
         unsigned indent = static_cast<unsigned>(strlen(lp) + strlen(header) + 1);
         It it = begin;
         format * first  = proc(*it);
         ++it;
+        // TODO: non-deterministic parameter evaluation
         return mk_group(m, mk_compose(m, 
                                       mk_string(m, lp), 
                                       mk_string(m, header), 
                                       mk_indent(m, indent, 
+                                                // TODO: non-deterministic parameter evaluation
                                                 mk_compose(m, 
                                                            mk_string(m, " "),
                                                            first,
@@ -146,6 +149,7 @@ namespace format_ns {
                      unsigned indent = FORMAT_DEFAULT_INDENT, char const * lp = "(", char const * rp = ")") {
         SASSERT(i >= 1);
         if (begin == end)
+            // TODO: non-deterministic parameter evaluation
             return mk_compose(m, mk_string(m, lp), mk_string(m, header), mk_string(m, rp));
         unsigned idx = 0;
         It end1 = begin;
@@ -155,9 +159,12 @@ namespace format_ns {
         format * first = proc(*it);
         ++it;
         return mk_group(m, 
+                        // TODO: non-deterministic parameter evaluation
                         mk_compose(m, 
+                                   // TODO: non-deterministic parameter evaluation
                                    mk_compose(m, mk_string(m, lp), mk_string(m, header)),
                                    mk_group(m, mk_indent(m, static_cast<unsigned>(strlen(header) + strlen(lp) + 1),
+                                                         // TODO: non-deterministic parameter evaluation
                                                          mk_compose(m, mk_string(m, " "), first, 
                                                                     mk_seq(m, it, end1, proc)))),
                                    mk_indent(m, indent, mk_seq(m, end1, end, proc)),
@@ -174,13 +181,16 @@ namespace format_ns {
     format * mk_seq4(ast_manager & m, It const & begin, It const & end, ToDoc proc, unsigned indent = FORMAT_DEFAULT_INDENT, 
                      char const * lp = "(", char const * rp = ")") {
         if (begin == end)
+            // TODO: non-deterministic parameter evaluation
             return mk_compose(m, mk_string(m, lp), mk_string(m, rp));
         unsigned indent1 = static_cast<unsigned>(strlen(lp));
         It it = begin;
         format * first = proc(*it);
         ++it;
+        // TODO: non-deterministic parameter evaluation
         return mk_group(m, mk_compose(m,
                                       mk_indent(m, indent1, mk_compose(m, mk_string(m, lp), first)),
+                                      // TODO: non-deterministic parameter evaluation
                                       mk_indent(m, indent, mk_compose(m, 
                                                                       mk_seq(m, it, end, proc), 
                                                                       mk_string(m, rp)))));

src/ast/fpa/fpa2bv_converter.cpp

@@ -300,6 +300,7 @@ void fpa2bv_converter::mk_uf(func_decl * f, unsigned num, expr * const * args, e
         bv_rng = m_bv_util.mk_sort(bv_sz);
         func_decl * bv_f = mk_bv_uf(f, f->get_domain(), bv_rng);
         bv_app = m.mk_app(bv_f, num, args);
+        // TODO: non-deterministic parameter evaluation
         flt_app = m_util.mk_fp(m_bv_util.mk_extract(bv_sz-1, bv_sz-1, bv_app),
                                m_bv_util.mk_extract(sbits+ebits-2, sbits-1, bv_app),
                                m_bv_util.mk_extract(sbits-2, 0, bv_app));
@@ -1245,6 +1246,7 @@ void fpa2bv_converter::mk_rem(sort * s, expr_ref & x, expr_ref & y, expr_ref & r
     dbg_decouple("fpa2bv_rem_y_sig_eq_rndd_sig", y_sig_eq_rndd_sig);
 
     expr_ref adj_cnd(m);
+    // TODO: non-deterministic parameter evaluation
     adj_cnd = m.mk_or(m.mk_and(rndd_exp_eq_y_exp, y_sig_le_rndd_sig),
                       m.mk_and(rndd_exp_eq_y_exp_m1, y_sig_le_rndd_sig, m.mk_not(y_sig_eq_rndd_sig)),
                       m.mk_and(rndd_exp_eq_y_exp_m1, y_sig_eq_rndd_sig, m.mk_not(huge_div_is_even)));
@@ -1646,6 +1648,7 @@ void fpa2bv_converter::mk_fma(func_decl * f, unsigned num, expr * const * args,
     // Alignment shift with sticky bit computation.
     expr_ref shifted_big(m), shifted_f_sig(m);
     expr_ref alignment_sticky_raw(m), alignment_sticky(m);
+    // TODO: non-deterministic parameter evaluation
     shifted_big = m_bv_util.mk_bv_lshr(
         m_bv_util.mk_concat(f_sig, m_bv_util.mk_numeral(0, sbits)),
         m_bv_util.mk_zero_extend((3*sbits+3)-(ebits+2), exp_delta));
@@ -1876,6 +1879,7 @@ void fpa2bv_converter::mk_sqrt(func_decl * f, unsigned num, expr * const * args,
     res_sgn = zero1;
 
     expr_ref real_exp(m);
+    // TODO: non-deterministic parameter evaluation
     real_exp = m_bv_util.mk_bv_sub(m_bv_util.mk_sign_extend(1, a_exp), m_bv_util.mk_zero_extend(1, a_lz));
     res_exp = m_bv_util.mk_sign_extend(2, m_bv_util.mk_extract(ebits, 1, real_exp));
 
@@ -1907,6 +1911,7 @@ void fpa2bv_converter::mk_sqrt(func_decl * f, unsigned num, expr * const * args,
         S = m_bv_util.mk_concat(zero1, m_bv_util.mk_extract(sbits+4, 1, S));
 
         expr_ref twoQ_plus_S(m);
+        // TODO: non-deterministic parameter evaluation
         twoQ_plus_S = m_bv_util.mk_bv_add(m_bv_util.mk_concat(Q, zero1), m_bv_util.mk_concat(zero1, S));
         T = m_bv_util.mk_bv_sub(m_bv_util.mk_concat(R, zero1), twoQ_plus_S);
 
@@ -2098,6 +2103,7 @@ void fpa2bv_converter::mk_round_to_integral(sort * s, expr_ref & rm, expr_ref &
     expr_ref shift(m), shifted_sig(m), div(m), rem(m);
     shift = m_bv_util.mk_bv_sub(m_bv_util.mk_numeral(sbits - 1, sbits),
                                 m_bv_util.mk_sign_extend(sbits-ebits, a_exp));
+    // TODO: non-deterministic parameter evaluation
     shifted_sig = m_bv_util.mk_bv_lshr(m_bv_util.mk_concat(a_sig, zero_s),
                                        m_bv_util.mk_concat(zero_s, shift));
     div = m_bv_util.mk_extract(2*sbits-1, sbits, shifted_sig);
@@ -2451,6 +2457,7 @@ void fpa2bv_converter::mk_to_fp(func_decl * f, unsigned num, expr * const * args
         (void)to_sbits;
         SASSERT((unsigned)sz == to_sbits + to_ebits);
 
+        // TODO: non-deterministic parameter evaluation
         result = m_util.mk_fp(m_bv_util.mk_extract(sz - 1, sz - 1, bv),
                               m_bv_util.mk_extract(sz - 2, sz - to_ebits - 1, bv),
                               m_bv_util.mk_extract(sz - to_ebits - 2, 0, bv));
@@ -2611,6 +2618,7 @@ void fpa2bv_converter::mk_to_fp_float(sort * to_srt, expr * rm, expr * x, expr_r
 
             // subtract lz for subnormal numbers.
             expr_ref exp_sub_lz(m);
+            // TODO: non-deterministic parameter evaluation
             exp_sub_lz = m_bv_util.mk_bv_sub(m_bv_util.mk_sign_extend(2, exp), m_bv_util.mk_sign_extend(2, lz));
             dbg_decouple("fpa2bv_to_float_exp_sub_lz", exp_sub_lz);
 
@@ -2844,6 +2852,8 @@ void fpa2bv_converter::mk_to_fp_real(func_decl * f, sort * s, expr * rm, expr *
         expr_ref pzero(m), nzero(m);
         mk_pzero(result->get_sort(), pzero);
         mk_nzero(result->get_sort(), nzero);
+        // TODO: non-deterministic parameter evaluation
+        // TODO: non-deterministic parameter evaluation
         m_extra_assertions.push_back(m.mk_implies(m.mk_eq(x, zero), m.mk_or(m.mk_eq(result, pzero), m.mk_eq(result, nzero))));
     }
 
@@ -3398,6 +3408,7 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args
     // x is of the form +- [1].[sig][r][g][s] ... and at least bv_sz + 3 long
 
     expr_ref exp_m_lz(m), e_m_lz_m_bv_sz(m), shift(m), is_neg_shift(m), big_sig(m);
+    // TODO: non-deterministic parameter evaluation
     exp_m_lz = m_bv_util.mk_bv_sub(m_bv_util.mk_sign_extend(2, exp),
                                    m_bv_util.mk_zero_extend(2, lz));
 
@@ -3465,6 +3476,8 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args
     expr_ref ul(m), in_range(m);
     if (!is_signed) {
         ul = m_bv_util.mk_zero_extend(3, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, bv_sz)));
+        // TODO: non-deterministic parameter evaluation
+        // TODO: non-deterministic parameter evaluation
         in_range = m.mk_and(m.mk_or(m.mk_not(x_is_neg),
                                     m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz+3))),
                             m.mk_not(ovfl),
@@ -3482,6 +3495,7 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args
             ul = m_bv_util.mk_numeral(0, 4);
         ovfl = m.mk_or(ovfl, m_bv_util.mk_sle(pre_rounded, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, bv_sz + 3))));
         pre_rounded = m.mk_ite(x_is_neg, m_bv_util.mk_bv_neg(pre_rounded), pre_rounded);
+        // TODO: non-deterministic parameter evaluation
         in_range = m.mk_and(m.mk_not(ovfl),
                             m_bv_util.mk_sle(ll, pre_rounded),
                             m_bv_util.mk_sle(pre_rounded, ul));
@@ -4188,6 +4202,7 @@ void fpa2bv_converter::round(sort * s, expr_ref & rm, expr_ref & sgn, expr_ref &
     SASSERT(m_bv_util.get_bv_size(inc) == 1 && is_well_sorted(m, inc));
     dbg_decouple("fpa2bv_rnd_inc", inc);
 
+    // TODO: non-deterministic parameter evaluation
     sig = m_bv_util.mk_bv_add(m_bv_util.mk_zero_extend(1, sig),
         m_bv_util.mk_zero_extend(sbits, inc));
     SASSERT(is_well_sorted(m, sig));
@@ -4367,6 +4382,7 @@ void fpa2bv_converter_wrapped::mk_const(func_decl* f, expr_ref& result) {
         unsigned bv_sz = m_bv_util.get_bv_size(bv);
         unsigned sbits = m_util.get_sbits(s);
         SASSERT(bv_sz == m_util.get_ebits(s) + sbits);
+        // TODO: non-deterministic parameter evaluation
         result = m_util.mk_fp(m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, bv),
             m_bv_util.mk_extract(bv_sz - 2, sbits - 1, bv),
             m_bv_util.mk_extract(sbits - 2, 0, bv));
@@ -4419,9 +4435,13 @@ app_ref fpa2bv_converter_wrapped::unwrap(expr* e, sort* s) {
 
     if (m_util.is_rm(s)) {
         SASSERT(bv_sz == 3);
+        // TODO: non-deterministic parameter evaluation
         res = m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TIES_TO_AWAY, 3)), m_util.mk_round_nearest_ties_to_away(),
+            // TODO: non-deterministic parameter evaluation
             m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TIES_TO_EVEN, 3)), m_util.mk_round_nearest_ties_to_even(),
+                // TODO: non-deterministic parameter evaluation
                 m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TO_NEGATIVE, 3)), m_util.mk_round_toward_negative(),
+                    // TODO: non-deterministic parameter evaluation
                     m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TO_POSITIVE, 3)), m_util.mk_round_toward_positive(),
                         m_util.mk_round_toward_zero()))));
     }
@@ -4429,6 +4449,7 @@ app_ref fpa2bv_converter_wrapped::unwrap(expr* e, sort* s) {
         SASSERT(m_util.is_float(s));
         unsigned sbits = m_util.get_sbits(s);
         SASSERT(bv_sz == m_util.get_ebits(s) + sbits);
+        // TODO: non-deterministic parameter evaluation
         res = m_util.mk_fp(m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, e),
             m_bv_util.mk_extract(bv_sz - 2, sbits - 1, e),
             m_bv_util.mk_extract(sbits - 2, 0, e));

src/ast/fpa/fpa2bv_rewriter.cpp

@@ -258,6 +258,7 @@ bool fpa2bv_rewriter_cfg::reduce_var(var * t, expr_ref & result, proof_ref & res
         unsigned ebits = m_conv.fu().get_ebits(s);
         unsigned sbits = m_conv.fu().get_sbits(s);
         new_var = m().mk_var(t->get_idx(), m_conv.bu().mk_sort(sbits+ebits));
+        // TODO: non-deterministic parameter evaluation
         new_exp = m_conv.fu().mk_fp(m_conv.bu().mk_extract(sbits+ebits-1, sbits+ebits-1, new_var),
                                     m_conv.bu().mk_extract(ebits - 1, 0, new_var),
                                     m_conv.bu().mk_extract(sbits+ebits-2, ebits, new_var));

src/ast/normal_forms/defined_names.cpp

@@ -191,6 +191,7 @@ void defined_names::impl::mk_definition(expr * e, app * n, sort_ref_buffer & var
         bound_vars(var_sorts, var_names, MK_OR(n, MK_NOT(e)), n, defs);
     }
     else if (m.is_term_ite(e)) {
+        // TODO: non-deterministic parameter evaluation
         bound_vars(var_sorts, var_names, MK_OR(MK_NOT(to_app(e)->get_arg(0)), MK_EQ(n, to_app(e)->get_arg(1))), n, defs);
         bound_vars(var_sorts, var_names, MK_OR(to_app(e)->get_arg(0),         MK_EQ(n, to_app(e)->get_arg(2))), n, defs);
     }

src/ast/normal_forms/pull_quant.cpp

@@ -265,6 +265,7 @@ struct pull_quant::imp {
                 return BR_FAILED;
 
             if (m.proofs_enabled()) {
+                // TODO: non-deterministic parameter evaluation
                 result_pr = m.mk_pull_quant(m.mk_app(f, num, args), 
                                                     to_quantifier(result.get()));
             }

src/ast/rewriter/arith_rewriter.cpp

@@ -622,6 +622,7 @@ br_status arith_rewriter::factor_le_ge_eq(expr * arg1, expr * arg2, op_kind kind
             return BR_FAILED;
         expr_ref f2 = remove_factor(f, arg1);
         expr* z = m_util.mk_numeral(rational(0), m_util.is_int(arg1));
+        // TODO: non-deterministic parameter evaluation
         result = m.mk_or(m_util.mk_eq(f, z), m_util.mk_eq(f2, z));
         switch (kind) {
         case EQ: 
@@ -868,6 +869,7 @@ bool arith_rewriter::mk_eq_mod(expr* arg1, expr* arg2, expr_ref& result) {
         rational g = gcd(p, k, a, b);
         if (g == 1) {
             expr_ref nb(m_util.mk_numeral(b, true), m);
+            // TODO: non-deterministic parameter evaluation
             result = m.mk_eq(m_util.mk_mod(u, y),
                              m_util.mk_mod(m_util.mk_mul(nb, arg2), y));
             return true;            
@@ -1202,6 +1204,7 @@ br_status arith_rewriter::mk_div_core(expr * arg1, expr * arg2, expr_ref & resul
 }
 
 br_status arith_rewriter::mk_idivides(unsigned k, expr * arg, expr_ref & result) {
+    // TODO: non-deterministic parameter evaluation
     result = m.mk_eq(m_util.mk_mod(arg, m_util.mk_int(k)), m_util.mk_int(0));
     return BR_REWRITE2;
 }
@@ -1229,6 +1232,7 @@ br_status arith_rewriter::mk_idiv_core(expr * arg1, expr * arg2, expr_ref & resu
     } 
     if (arg1 == arg2) { 
         expr_ref zero(m_util.mk_int(0), m); 
+        // TODO: non-deterministic parameter evaluation
         result = m.mk_ite(m.mk_eq(arg1, zero), m_util.mk_idiv(zero, zero), m_util.mk_int(1)); 
         return BR_REWRITE3; 
     } 
@@ -1327,6 +1331,7 @@ expr_ref arith_rewriter::remove_divisor(expr* arg, expr* num, expr* den) {
     den = args2.empty() ? m_util.mk_int(1) : m_util.mk_mul(args2.size(), args2.data()); 
     expr_ref d(m_util.mk_idiv(num, den), m);
     expr_ref nd(m_util.mk_idiv(m_util.mk_uminus(num), m_util.mk_uminus(den)), m);
+    // TODO: non-deterministic parameter evaluation
     return expr_ref(m.mk_ite(m.mk_eq(zero, arg), 
                                m_util.mk_idiv(zero, zero), 
                                m.mk_ite(m_util.mk_ge(arg, zero), 
@@ -1427,6 +1432,7 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
 
     expr* x = nullptr, * y = nullptr, * z = nullptr;
     if (is_num2 && v2.is_pos() && m_util.is_mul(arg1, x, y) && m_util.is_numeral(x, v1, is_int) && v1 > 0 && divides(v1, v2)) {
+        // TODO: non-deterministic parameter evaluation
         result = m_util.mk_mul(m_util.mk_int(v1), m_util.mk_mod(y, m_util.mk_int(v2/v1)));        
         return BR_REWRITE1;
     }
@@ -2083,12 +2089,14 @@ expr * arith_rewriter::mk_sin_value(rational const & k) {
     if (k_prime == rational(1, 12) || k_prime == rational(11, 12)) {
         // sin(1/12 pi)  == sin(11/12 pi)  ==  [sqrt(6) - sqrt(2)]/4
         // sin(13/12 pi) == sin(23/12 pi)  == -[sqrt(6) - sqrt(2)]/4
+        // TODO: non-deterministic parameter evaluation
         expr * result = m_util.mk_div(m_util.mk_sub(mk_sqrt(rational(6)), mk_sqrt(rational(2))), m_util.mk_numeral(rational(4), false));
         return neg ? m_util.mk_uminus(result) : result;
     }
     if (k_prime == rational(5, 12) || k_prime == rational(7, 12)) {
         // sin(5/12 pi)  == sin(7/12 pi)   == [sqrt(6) + sqrt(2)]/4
         // sin(17/12 pi) == sin(19/12 pi)  == -[sqrt(6) + sqrt(2)]/4
+        // TODO: non-deterministic parameter evaluation
         expr * result = m_util.mk_div(m_util.mk_add(mk_sqrt(rational(6)), mk_sqrt(rational(2))), m_util.mk_numeral(rational(4), false));
         return neg ? m_util.mk_uminus(result) : result;
     }
@@ -2267,6 +2275,7 @@ br_status arith_rewriter::mk_tan_core(expr * arg, expr_ref & result) {
 
  end:
     if (m_expand_tan) {
+        // TODO: non-deterministic parameter evaluation
         result = m_util.mk_div(m_util.mk_sin(arg), m_util.mk_cos(arg));
         return BR_REWRITE2;
     }

src/ast/rewriter/bv2int_translator.cpp

@@ -222,6 +222,7 @@ void bv2int_translator::translate_bv(app* e) {
             auto A = rational::power_of_two(sz - n);
             auto B = rational::power_of_two(n);
             auto hi = mul(r, a.mk_int(A));
+            // TODO: non-deterministic parameter evaluation
             auto lo = amod(e, a.mk_idiv(umod(e, 0), a.mk_int(B)), A);
             r = add(hi, lo);
         }
@@ -364,6 +365,7 @@ void bv2int_translator::translate_bv(app* e) {
             rational N = bv_size(e);
             expr* x = umod(e, 0), * y = umod(e, 1);
             expr* signx = a.mk_ge(x, a.mk_int(N / 2));
+            // TODO: non-deterministic parameter evaluation
             r = m.mk_ite(signx, a.mk_int(-1), a.mk_int(0));
             IF_VERBOSE(4, verbose_stream() << "ashr " << mk_bounded_pp(e, m) << " " << bv.get_bv_size(e) << "\n");
             for (unsigned i = 0; i < sz; ++i) {
@@ -431,6 +433,8 @@ void bv2int_translator::translate_bv(app* e) {
         break;
     case OP_BCOMP:
         bv_expr = e->get_arg(0);
+        // TODO: non-deterministic parameter evaluation
+        // TODO: non-deterministic parameter evaluation
         r = m.mk_ite(m.mk_eq(umod(bv_expr, 0), umod(bv_expr, 1)), a.mk_int(1), a.mk_int(0));
         break;
     case OP_BSMOD_I:
@@ -449,6 +453,7 @@ void bv2int_translator::translate_bv(app* e) {
         r = a.mk_uminus(u);
         r = m.mk_ite(m.mk_and(m.mk_not(signx), signy), add(u, y), r);
         r = m.mk_ite(m.mk_and(signx, m.mk_not(signy)), a.mk_sub(y, u), r);
+        // TODO: non-deterministic parameter evaluation
         r = m.mk_ite(m.mk_and(m.mk_not(signx), m.mk_not(signy)), u, r);
         r = if_eq(u, 0, a.mk_int(0), r);
         r = if_eq(y, 0, x, r);
@@ -472,6 +477,7 @@ void bv2int_translator::translate_bv(app* e) {
         y = m.mk_ite(signy, a.mk_sub(a.mk_int(N), y), y);
         expr* d = a.mk_idiv(x, y);
         r = m.mk_ite(m.mk_iff(signx, signy), d, a.mk_uminus(d));
+        // TODO: non-deterministic parameter evaluation
         r = if_eq(y, 0, m.mk_ite(signx, a.mk_int(1), a.mk_int(-1)), r);
         break;
     }
@@ -566,17 +572,22 @@ void bv2int_translator::translate_basic(app* e) {
             rational N = rational::power_of_two(bv.get_bv_size(bv_expr));
             if (a.is_numeral(arg(0)) || a.is_numeral(arg(1)) ||
                 is_bounded(arg(0), N) || is_bounded(arg(1), N)) {
+                // TODO: non-deterministic parameter evaluation
                 set_translated(e, m.mk_eq(umod(bv_expr, 0), umod(bv_expr, 1)));
             }
             else {
+                // TODO: non-deterministic parameter evaluation
                 m_args[0] = a.mk_sub(arg(0), arg(1));
+                // TODO: non-deterministic parameter evaluation
                 set_translated(e, m.mk_eq(umod(bv_expr, 0), a.mk_int(0)));
             }
         }
         else
+            // TODO: non-deterministic parameter evaluation
             set_translated(e, m.mk_eq(arg(0), arg(1)));
     }
     else if (m.is_ite(e))
+        // TODO: non-deterministic parameter evaluation
         set_translated(e, m.mk_ite(arg(0), arg(1), arg(2)));
     else if (m_is_plugin)
         set_translated(e, e);
@@ -661,6 +672,7 @@ expr* bv2int_translator::amod(expr* bv_expr, expr* x, rational const& N) {
     rational v;
     expr* r = nullptr, * c = nullptr, * t = nullptr, * e = nullptr;
     if (m.is_ite(x, c, t, e))
+        // TODO: non-deterministic parameter evaluation
         r = m.mk_ite(c, amod(bv_expr, t, N), amod(bv_expr, e, N));
     else if (a.is_idiv(x, t, e) && a.is_numeral(t, v) && 0 <= v && v < N && is_non_negative(bv_expr, e))
         r = x;
@@ -684,6 +696,7 @@ void bv2int_translator::translate_eq(expr* e) {
         ensure_translated(y);
         m_args.reset();
         m_args.push_back(a.mk_sub(translated(x), translated(y)));
+        // TODO: non-deterministic parameter evaluation
         set_translated(e, m.mk_eq(umod(x, 0), a.mk_int(0)));
     }
     m_preds.push_back(e);

src/ast/rewriter/bv_rewriter.cpp

@@ -384,6 +384,7 @@ br_status bv_rewriter::rw_leq_overflow(bool is_signed, expr * a, expr * b, expr_
     }
     else {
         SASSERT(lower.is_pos());
+        // TODO: non-deterministic parameter evaluation
         result = m.mk_and(m_util.mk_ule(mk_numeral(lower, sz), common),
                             m_util.mk_ule(common, mk_numeral(upper, sz)));
     }
@@ -447,6 +448,7 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
             return BR_DONE;
         }
         if (common > 0) {
+            // TODO: non-deterministic parameter evaluation
             result = m_util.mk_ule(concat(numa - common, a->get_args() + common),
                                    concat(numb - common, b->get_args() + common));
             return BR_REWRITE2;
@@ -469,7 +471,9 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
             return BR_DONE;
         }
         if (new_numa != numa) {
+            // TODO: non-deterministic parameter evaluation
             result = is_signed ? m_util.mk_sle(concat(new_numa, a->get_args()), concat(new_numb, b->get_args()))
+                               // TODO: non-deterministic parameter evaluation
                                : m_util.mk_ule(concat(new_numa, a->get_args()), concat(new_numb, b->get_args()));
             return BR_REWRITE2;
         }
@@ -870,6 +874,7 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
     expr* c = nullptr, *t = nullptr, *e = nullptr;
     if (m.is_ite(arg, c, t, e) &&
         (t->get_ref_count() == 1 || e->get_ref_count() == 1 || !m.is_ite(t) || !m.is_ite(e))) {
+        // TODO: non-deterministic parameter evaluation
         result = m.mk_ite(c, m_mk_extract(high, low, t), m_mk_extract(high, low, e));
         return BR_REWRITE2;
     }
@@ -1083,6 +1088,7 @@ br_status bv_rewriter::mk_bv_ashr(expr * arg1, expr * arg2, expr_ref & result) {
         // (bvlshr x k) -> (concat bv0:k (extract [n-1:k] x))
 
         unsigned k = r2.get_unsigned();
+        // TODO: non-deterministic parameter evaluation
         result = m_util.mk_concat(mk_zero(k), m_mk_extract(bv_size - 1, k, arg1));
         return BR_REWRITE2;
     }
@@ -1120,6 +1126,7 @@ br_status bv_rewriter::mk_bv_sdiv_core(expr * arg1, expr * arg2, bool hi_div0, e
             }
             else {
                 // The "hardware interpretation" for (bvsdiv x 0) is (ite (bvslt x #x0000) #x0001 #xffff)
+                // TODO: non-deterministic parameter evaluation
                 result = m.mk_ite(m.mk_app(get_fid(), OP_SLT, arg1, mk_zero(bv_size)),
                                     mk_one(bv_size),
                                     mk_numeral(rational::power_of_two(bv_size) - numeral(1), bv_size));
@@ -1250,6 +1257,7 @@ br_status bv_rewriter::mk_bv_srem_core(expr * arg1, expr * arg2, bool hi_div0, e
     }
 
     bv_size = get_bv_size(arg2);
+    // TODO: non-deterministic parameter evaluation
     result = m.mk_ite(m.mk_eq(arg2, mk_zero(bv_size)),
                         m.mk_app(get_fid(), OP_BSREM0, arg1),
                         m.mk_app(get_fid(), OP_BSREM_I, arg1, arg2));
@@ -1467,6 +1475,7 @@ br_status bv_rewriter::mk_bv_smod_core(expr * arg1, expr * arg2, bool hi_div0, e
     }
 
     bv_size = get_bv_size(arg2);
+    // TODO: non-deterministic parameter evaluation
     result = m.mk_ite(m.mk_eq(arg2, mk_zero(bv_size)),
                         m.mk_app(get_fid(), OP_BSMOD0, arg1),
                         m.mk_app(get_fid(), OP_BSMOD_I, arg1, arg2));
@@ -1686,6 +1695,7 @@ br_status bv_rewriter::mk_concat(unsigned num_args, expr * const * args, expr_re
                 ptr_buffer<expr> args1, args2;
                 for (unsigned i = 0; i < new_args.size(); ++i)
                     args1.push_back(y), args2.push_back(z);
+                // TODO: non-deterministic parameter evaluation
                 result = m.mk_ite(x, m_util.mk_concat(args1), m_util.mk_concat(args2));
                 return BR_REWRITE2;
             }
@@ -2336,6 +2346,7 @@ br_status bv_rewriter::mk_bv_comp(expr * arg1, expr * arg2, expr_ref & result) {
         return BR_DONE;
     }
 
+    // TODO: non-deterministic parameter evaluation
     result = m.mk_ite(m.mk_eq(arg1, arg2),
                         mk_one(1),
                         mk_zero(1));
@@ -2618,6 +2629,7 @@ br_status bv_rewriter::mk_blast_eq_value(expr * lhs, expr * rhs, expr_ref & resu
     ptr_buffer<expr> new_args;
     for (unsigned i = 0; i < sz; i++) {
         bool bit0 = (v % two).is_zero();
+        // TODO: non-deterministic parameter evaluation
         new_args.push_back(m.mk_eq(m_mk_extract(i,i, lhs),
                                      mk_numeral(bit0 ? 0 : 1, 1)));
         div(v, two, v);
@@ -2663,6 +2675,7 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
         unsigned rsz1 = sz1 - low1;
         unsigned rsz2 = sz2 - low2;
         if (rsz1 == rsz2) {
+            // TODO: non-deterministic parameter evaluation
             new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1),
                                       m_mk_extract(sz2 - 1, low2, arg2)));
             low1 = 0;
@@ -2672,6 +2685,7 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
             continue;
         }
         else if (rsz1 < rsz2) {
+            // TODO: non-deterministic parameter evaluation
             new_eqs.push_back(m.mk_eq(m_mk_extract(sz1  - 1, low1, arg1),
                                       m_mk_extract(rsz1 + low2 - 1, low2, arg2)));
             low1  = 0;
@@ -2679,6 +2693,7 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
             --i1;
         }
         else {
+            // TODO: non-deterministic parameter evaluation
             new_eqs.push_back(m.mk_eq(m_mk_extract(rsz2 + low1 - 1, low1, arg1),
                                       m_mk_extract(sz2  - 1, low2, arg2)));
             low1 += rsz2;
@@ -3110,6 +3125,7 @@ br_status bv_rewriter::mk_distinct(unsigned num_args, expr * const * args, expr_
 
 br_status bv_rewriter::mk_bvsmul_overflow(unsigned num, expr * const * args, expr_ref & result) {
     SASSERT(num == 2);
+    // TODO: non-deterministic parameter evaluation
     result = m.mk_or(
             m.mk_not(m_util.mk_bvsmul_no_ovfl(args[0], args[1])),
             m.mk_not(m_util.mk_bvsmul_no_udfl(args[0], args[1]))
@@ -3279,6 +3295,7 @@ br_status bv_rewriter::mk_bvsdiv_overflow(unsigned num, expr * const * args, exp
     auto sz = get_bv_size(args[1]);
     auto minSigned = mk_numeral(rational::power_of_two(sz-1), sz);
     auto minusOne = mk_numeral(rational::power_of_two(sz) - 1, sz);
+    // TODO: non-deterministic parameter evaluation
     result = m.mk_and(m.mk_eq(args[0], minSigned), m.mk_eq(args[1], minusOne));
     return BR_REWRITE_FULL;
 }

src/ast/rewriter/enum2bv_rewriter.cpp

@@ -74,6 +74,7 @@ struct enum2bv_rewriter::imp {
             if (is_unate(s)) {
                 expr_ref one(m_bv.mk_numeral(rational::one(), 1), m);
                 for (unsigned i = 0; i + 2 < domain_size; ++i) {                    
+                    // TODO: non-deterministic parameter evaluation
                     bounds.push_back(m.mk_implies(m.mk_eq(one, m_bv.mk_extract(i + 1, i + 1, x)),
                                                           m.mk_eq(one, m_bv.mk_extract(i, i, x))));
                 }

src/ast/rewriter/factor_equivs.cpp

@@ -136,6 +136,7 @@ bool equiv_to_expr_full(expr_equiv_class &equiv, expr_ref_vector &out) {
         for (auto a = eq_class.begin(), end = eq_class.end(); a != end; ++a) {
             expr_equiv_class::iterator b(a);
             for (++b; b != end; ++b) {
+                // TODO: non-deterministic parameter evaluation
                 out.push_back(m.mk_eq(*a, *b));
                 dirty = true;
             }

src/ast/rewriter/factor_rewriter.cpp

@@ -141,7 +141,9 @@ void factor_rewriter::mk_is_negative(expr_ref& result, expr_ref_vector& eqs) {
                 pos0 = pos;
             }
             else {
+                // TODO: non-deterministic parameter evaluation
                 tmp = m().mk_or(m().mk_and(pos, pos0), m().mk_and(neg, neg0));
+                // TODO: non-deterministic parameter evaluation
                 neg0 = m().mk_or(m().mk_and(neg, pos0), m().mk_and(pos, neg0));
                 pos0 = tmp;
             }

src/ast/rewriter/fpa_rewriter.cpp

@@ -494,6 +494,7 @@ br_status fpa_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
     }
     if (m_util.is_ninf(arg1)) {
         // -oo < arg2 -->  not(arg2 = -oo) and not(arg2 = NaN)
+        // TODO: non-deterministic parameter evaluation
         result = m().mk_and(m().mk_not(m().mk_eq(arg2, arg1)), mk_neq_nan(arg2));
         return BR_REWRITE3;
     }
@@ -509,6 +510,7 @@ br_status fpa_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
     }
     if (m_util.is_pinf(arg2)) {
         // arg1 < +oo --> not(arg1 = +oo) and not(arg1 = NaN)
+        // TODO: non-deterministic parameter evaluation
         result = m().mk_and(m().mk_not(m().mk_eq(arg1, arg2)), mk_neq_nan(arg1));
         return BR_REWRITE3;
     }

src/ast/rewriter/maximize_ac_sharing.cpp

@@ -58,6 +58,7 @@ br_status maximize_ac_sharing::reduce_app(func_decl * f, unsigned num_args, expr
             for (unsigned j = i + 1; j < num_args; j++) {
                 if (contains(f, _args[i], _args[j])) {
                     TRACE(ac_sharing_detail, tout << "reusing args: " << i << " " << j << "\n";);
+                    // TODO: non-deterministic parameter evaluation
                     _args[i] = m.mk_app(f, _args[i], _args[j]);
                     SASSERT(num_args > 1);
                     for (unsigned w = j; w + 1 < num_args; w++) {
@@ -81,6 +82,7 @@ br_status maximize_ac_sharing::reduce_app(func_decl * f, unsigned num_args, expr
             }
             else {
                 insert(f, _args[i], _args[i+1]);
+                // TODO: non-deterministic parameter evaluation
                 _args[j] = m.mk_app(f, _args[i], _args[i+1]);
             }
         }

src/ast/rewriter/poly_rewriter_def.h

@@ -923,6 +923,7 @@ bool poly_rewriter<Config>::hoist_multiplication(expr_ref& som) {
             }
             if (mul_map.find(e, j) && valid[j] && j != k) {
                 m_curr_sort = adds[k]->get_sort();
+                // TODO: non-deterministic parameter evaluation
                 adds[j]  = merge_muls(adds[j], adds[k]);
                 adds[k]  = mk_numeral(rational(0)); 
                 valid[j] = false;
@@ -1065,6 +1066,7 @@ template<typename Config>
 expr* poly_rewriter<Config>::apply_hoist(expr* a, numeral const& g, obj_hashtable<expr> const& shared) {
     expr* c = nullptr, *t = nullptr, *e = nullptr;
     if (M().is_ite(a, c, t, e)) {
+        // TODO: non-deterministic parameter evaluation
         return M().mk_ite(c, apply_hoist(t, g, shared), apply_hoist(e, g, shared));
     }
     rational k;

src/ast/rewriter/quant_hoist.cpp

@@ -249,6 +249,7 @@ private:
                     pull_quantifier(t1, qt, vars, tt1, use_fresh, rewrite_ok);
                     nt1 = m.mk_not(t1);
                     pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok);
+                    // TODO: non-deterministic parameter evaluation
                     result = m.mk_and(m.mk_or(ntt1, tt2), m.mk_or(tt1, tt3));
                 }
                 else {
@@ -263,6 +264,7 @@ private:
                 nt2 = m.mk_not(t2);
                 pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok);
                 pull_quantifier(nt2, qt, vars, ntt2, use_fresh, rewrite_ok);
+                // TODO: non-deterministic parameter evaluation
                 result = m.mk_and(m.mk_or(ntt1, tt2), m.mk_or(ntt2, tt1));
             }
             else {

src/ast/rewriter/rewriter_def.h

@@ -574,6 +574,7 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
         num_no_pats = j;
     }
     if (ProofGen) {
+        // TODO: non-deterministic parameter evaluation
         quantifier_ref new_q(m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body), m());
         m_pr = nullptr;
         if (q != new_q) {
@@ -599,6 +600,7 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
         TRACE(reduce_quantifier_bug, tout << mk_ismt2_pp(q, m()) << " " << mk_ismt2_pp(new_body, m()) << "\n";);
         if (!m_cfg.reduce_quantifier(q, new_body, new_pats.data(), new_no_pats.data(), m_r, m_pr)) {
             if (fr.m_new_child) {
+                // TODO: non-deterministic parameter evaluation
                 m_r = m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body);
             }
             else {

src/ast/rewriter/seq_eq_solver.cpp

@@ -344,6 +344,7 @@ namespace seq {
 
         if (ctx.expr2rep(xs[0]) == ctx.expr2rep(ys[0]))
             return false;
+        // TODO: non-deterministic parameter evaluation
         expr_ref eq(m.mk_eq(xs[0], ys[0]), m);
         expr* veq = ctx.expr2rep(eq);
         if (m.is_true(veq))

src/ast/rewriter/seq_rewriter.cpp

@@ -2764,6 +2764,7 @@ br_status seq_rewriter::mk_re_reverse(expr* r, expr_ref& result) {
         return BR_REWRITE2;
     }
     else if (m().is_ite(r, p, r1, r2)) {
+        // TODO: non-deterministic parameter evaluation
         result = m().mk_ite(p, re().mk_reverse(r1), re().mk_reverse(r2));
         return BR_REWRITE2;
     }
@@ -4282,6 +4283,7 @@ bool seq_rewriter::rewrite_contains_pattern(expr* a, expr* b, expr_ref& result)
                 suffix = re().mk_concat(suffix, re().mk_to_re(e));
             suffix = re().mk_concat(suffix, full);
         }
+        // TODO: non-deterministic parameter evaluation
         fmls.push_back(m().mk_and(re().mk_in_re(x, prefix),
                                   re().mk_in_re(y, suffix)));
     }

src/ast/rewriter/th_rewriter.cpp

@@ -143,10 +143,12 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
         expr * x;
         unsigned val;
         if (m_bv_rw.is_eq_bit(lhs, x, val)) {
+            // TODO: non-deterministic parameter evaluation
             result = m().mk_eq(x, m().mk_ite(rhs, m_bv_rw.mk_numeral(val, 1), m_bv_rw.mk_numeral(1-val, 1)));
             return BR_REWRITE2;
         }
         if (m_bv_rw.is_eq_bit(rhs, x, val)) {
+            // TODO: non-deterministic parameter evaluation
             result = m().mk_eq(x, m().mk_ite(lhs, m_bv_rw.mk_numeral(val, 1), m_bv_rw.mk_numeral(1-val, 1)));
             return BR_REWRITE2;
         }

src/ast/sls/sls_array_plugin.cpp

@@ -414,6 +414,7 @@ namespace sls {
         }
         expr_ref sel1(a.mk_select(args1), m);
         expr_ref sel2(a.mk_select(args2), m);
+        // TODO: non-deterministic parameter evaluation
         bool r = ctx.add_constraint(m.mk_implies(m.mk_eq(sel1, sel2), m.mk_eq(x, y)));
         if (r)
             ++m_stats.m_num_axioms;        

src/ast/sls/sls_datatype_plugin.cpp

@@ -254,6 +254,7 @@ namespace sls {
                     expr_ref_vector args(m);
                     for (auto a : acc)
                         args.push_back(m.mk_app(a, t));
+                    // TODO: non-deterministic parameter evaluation
                     m_axioms.push_back(m.mk_iff(m.mk_app(r, t), m.mk_eq(t, m.mk_app(c, args))));
                 }
             }

src/ast/sls/sls_seq_plugin.cpp

@@ -161,6 +161,7 @@ namespace sls {
 
                 if (r == 0 || sx.length() == 0)
                     // create lemma: len(x) = 0 <=> x = ""
+                    // TODO: non-deterministic parameter evaluation
                     ctx.add_constraint(m.mk_eq(m.mk_eq(e, a.mk_int(0)), m.mk_eq(x, seq.str.mk_string(""))));
 
                 if (ctx.rand(2) == 0 && update(e, rational(sx.length())))

src/cmd_context/cmd_context.cpp

@@ -1759,6 +1759,7 @@ void cmd_context::check_sat(unsigned num_assumptions, expr * const * assumptions
             for (unsigned i = 0; i < sz; ++i) {
                 if (m_assertion_names.size() > i && m_assertion_names[i]) {
                     asms.push_back(m_assertion_names[i]);
+                    // TODO: non-deterministic parameter evaluation
                     assertions.push_back(m().mk_implies(m_assertion_names[i], m_assertions[i]));
                 }
                 else {

src/model/model_smt2_pp.cpp

@@ -123,6 +123,7 @@ static void pp_uninterp_sorts(std::ostream & out, ast_printer_context & ctx, mod
             f_cond = f_conds[0];
         format_ref f_s(fm(m));
         ctx.pp(s, f_s);
+        // TODO: non-deterministic parameter evaluation
         format * f_args[2] = { mk_compose(m, 
                                           mk_string(m, "((x "),
                                           mk_indent(m, 4, mk_compose(m, f_s.get(), mk_string(m, "))")))),
@@ -252,6 +253,7 @@ static void pp_funs(std::ostream & out, ast_printer_context & ctx, model_core co
                 ctx.pp(e->get_result(), f_result);
                 if (i > 0)
                     f_entries.push_back(mk_line_break(m));
+                // TODO: non-deterministic parameter evaluation
                 f_entries.push_back(mk_group(m, mk_compose(m, 
                                                            mk_string(m, "(ite "),
                                                            mk_indent(m, 5, f_entry_cond),
@@ -272,7 +274,9 @@ static void pp_funs(std::ostream & out, ast_printer_context & ctx, model_core co
             fname = mk_smt2_quoted_symbol(f->get_name());
         else
             fname = f->get_name().str();
+        // TODO: non-deterministic parameter evaluation
         def = mk_indent(m, indent, mk_compose(m, 
+                                              // TODO: non-deterministic parameter evaluation
                                               mk_compose(m, 
                                                          mk_string(m, "(define-fun "),
                                                          mk_string(m, fname),

src/muz/rel/check_relation.cpp

@@ -533,6 +533,7 @@ namespace datalog {
             unsigned c1 = m_cols[0];
             for (unsigned i = 1; i < m_cols.size(); ++i) {
                 unsigned c2 = m_cols[i];
+                // TODO: non-deterministic parameter evaluation
                 conds.push_back(m.mk_eq(m.mk_var(c1, sig[c1]), m.mk_var(c2, sig[c2])));
             }
             cond = mk_and(m, conds.size(), conds.data());

src/muz/rel/dl_base.cpp

@@ -454,6 +454,7 @@ namespace datalog {
             r.get_fact(fact);
             conjs.reset();
             for (unsigned i = 0; i < fact.size(); ++i) {
+                // TODO: non-deterministic parameter evaluation
                 conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i])));
             }
             brw.mk_and(conjs.size(), conjs.data(), fml);

src/muz/rel/dl_bound_relation.cpp

@@ -658,16 +658,19 @@ namespace datalog {
         relation_signature const& sig = get_signature();
         for (unsigned i = 0; i < sig.size(); ++i) {
             if (i != find(i)) {
+                // TODO: non-deterministic parameter evaluation
                 conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), m.mk_var(find(i), sig[find(i)])));
                 continue;
             }
             uint_set2 const& upper = (*this)[i];
             uint_set::iterator it = upper.lt.begin(), end = upper.lt.end();
             for (; it != end; ++it) {
+                // TODO: non-deterministic parameter evaluation
                 conjs.push_back(arith.mk_lt(m.mk_var(i, sig[i]), m.mk_var(*it, sig[*it])));
             }
             it = upper.le.begin(), end = upper.le.end();
             for (; it != end; ++it) {
+                // TODO: non-deterministic parameter evaluation
                 conjs.push_back(arith.mk_le(m.mk_var(i, sig[i]), m.mk_var(*it, sig[*it])));
             }
         }

src/muz/rel/dl_finite_product_relation.cpp

@@ -2363,6 +2363,7 @@ namespace datalog {
             unsigned rel_idx = static_cast<unsigned>(fact[fact_sz-1]);
             m_others[rel_idx]->to_formula(tmp);
             for (unsigned i = 0; i + 1 < fact_sz; ++i) {
+                // TODO: non-deterministic parameter evaluation
                 conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i])));
             }
             sh(tmp, fact_sz-1, tmp);

src/muz/rel/dl_interval_relation.cpp

@@ -375,6 +375,7 @@ namespace datalog {
         relation_signature const& sig = get_signature();
         for (unsigned i = 0; i < sig.size(); ++i) {
             if (i != find(i)) {
+                // TODO: non-deterministic parameter evaluation
                 conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), 
                                         m.mk_var(find(i), sig[find(i)])));
                 continue;

src/muz/spacer/spacer_convex_closure.cpp

@@ -369,6 +369,7 @@ void convex_closure::cc_1dim(const expr_ref &var, expr_ref_vector &out) {
             m_data.get_col(j, data);
             std::sort(data.begin(), data.end(), gt_proc);
             if (infer_div_pred(data, cr, off)) {
+                // TODO: non-deterministic parameter evaluation
                 out.push_back(mk_eq_mod(v, cr, off));
             }
         }
@@ -378,6 +379,7 @@ void convex_closure::cc_1dim(const expr_ref &var, expr_ref_vector &out) {
 expr *convex_closure::mk_eq_mod(expr *v, rational d, rational r) {
     expr *res = nullptr;
     if (m_arith.is_int(v)) {
+        // TODO: non-deterministic parameter evaluation
         res = m.mk_eq(m_arith.mk_mod(v, m_arith.mk_int(d)), m_arith.mk_int(r));
     } else if (m_bv.is_bv(v)) {
         res = m.mk_eq(m_bv.mk_bv_urem(v, m_bv.mk_numeral(d, m_bv_sz)),

src/muz/spacer/spacer_generalizers.cpp

@@ -251,6 +251,7 @@ void lemma_array_eq_generalizer::operator() (lemma_ref &lemma)
     expr_ref_vector eqs(m);
     for (unsigned i = 0, sz = vsymbs.size(); i < sz; ++i) {
         for (unsigned j = i + 1; j < sz; ++j) {
+            // TODO: non-deterministic parameter evaluation
             eqs.push_back(m.mk_eq(m.mk_const(vsymbs.get(i)),
                                   m.mk_const(vsymbs.get(j))));
         }

src/muz/spacer/spacer_qe_project.cpp

@@ -559,6 +559,7 @@ class arith_project_util {
                   tout << "lcm of divs: " << lcm_divs << "\n";);
         }
 
+        // TODO: non-deterministic parameter evaluation
         expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m);
         expr_ref x_term_val(m);
 
@@ -626,6 +627,7 @@ class arith_project_util {
                 // (lcm_coeffs * var_val) % lcm_divs instead
                 rational var_val_num;
                 VERIFY(a.is_numeral(var_val, var_val_num));
+                // TODO: non-deterministic parameter evaluation
                 x_term_val = a.mk_numeral(
                     mod(lcm_coeffs * var_val_num, lcm_divs), a.mk_int());
                 TRACE(qe, tout << "Substitution for (lcm_coeffs * x): "
@@ -648,6 +650,7 @@ class arith_project_util {
                     // syntactic structure
                     m_rw(new_lit);
                     new_lit = m.mk_eq(
+                        // TODO: non-deterministic parameter evaluation
                         a.mk_mod(new_lit, a.mk_numeral(m_divs[i], a.mk_int())),
                         z);
                 } else if (m_eq[i] || (num_pos == 0 && m_coeffs[i].is_pos()) ||
@@ -738,6 +741,7 @@ class arith_project_util {
                 mk_add(m_terms.get(max_t), a.mk_numeral(offset, a.mk_int()));
             if (m_strict[max_t]) {
                 x_term_val = a.mk_add(
+                    // TODO: non-deterministic parameter evaluation
                     x_term_val, a.mk_numeral(rational::one(), a.mk_int()));
             }
             if (m_coeffs[max_t].is_pos()) {
@@ -976,6 +980,7 @@ class arith_project_util {
             return;
         }
 
+        // TODO: non-deterministic parameter evaluation
         expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m);
         bool is_mod_eq = false;
 
@@ -1021,6 +1026,7 @@ class arith_project_util {
                 lits.push_back(a.mk_le(z, t2));
                 // t2 < abs (num_val)
                 lits.push_back(
+                    // TODO: non-deterministic parameter evaluation
                     a.mk_lt(t2, a.mk_numeral(abs(num_val), a.mk_int())));
 
                 new_fml = m.mk_and(lits.size(), lits.data());
@@ -1073,6 +1079,7 @@ class arith_project_util {
      */
     void mk_lit_substitutes(expr_ref const &x_term_val, expr_map &map,
                             unsigned idx) {
+        // TODO: non-deterministic parameter evaluation
         expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m);
         expr_ref cxt(m), new_lit(m);
         for (unsigned i = 0; i < m_lits.size(); ++i) {
@@ -1101,6 +1108,7 @@ class arith_project_util {
                     // top-level operator
                     m_rw(cxt);
                     new_lit = m.mk_eq(
+                        // TODO: non-deterministic parameter evaluation
                         a.mk_mod(cxt, a.mk_numeral(m_divs[i], a.mk_int())), z);
                 }
             }

src/muz/spacer/spacer_util.cpp

@@ -359,6 +359,7 @@ void expand_literals(ast_manager &m, expr_ref_vector &conjs) {
             rational two(2);
             for (unsigned j = 0; j < bv_size; ++j) {
                 parameter p(j);
+                // TODO: non-deterministic parameter evaluation
                 expr *e = m.mk_eq(m.mk_app(bv.get_family_id(), OP_BIT1),
                                   bv.mk_extract(j, j, c));
                 if ((r % two).is_zero()) { e = m.mk_not(e); }

src/muz/transforms/dl_mk_array_blast.cpp

@@ -225,8 +225,10 @@ namespace datalog {
                 get_select_args(a1, args1);
                 get_select_args(a2, args2);
                 for (unsigned j = 0; j < args1.size(); ++j) {
+                    // TODO: non-deterministic parameter evaluation
                     eqs.push_back(m.mk_eq(args1[j], args2[j]));
                 }
+                // TODO: non-deterministic parameter evaluation
                 conjs.push_back(m.mk_implies(m.mk_and(eqs.size(), eqs.data()), m.mk_eq(v1, v2)));
             }
         }

src/muz/transforms/dl_mk_scale.cpp

@@ -55,6 +55,7 @@ namespace datalog {
 				for (unsigned i = 0; i < old_p->get_arity(); ++i) {
 					subst.push_back(m.mk_var(i, old_p->get_domain(i)));
 				}
+				// TODO: non-deterministic parameter evaluation
 				subst.push_back(a.mk_numeral(rational(1), a.mk_real()));
 
 				SASSERT(!new_fi->is_partial() && new_fi->num_entries() == 0);

src/opt/opt_context.cpp

@@ -1066,6 +1066,7 @@ namespace opt {
         expr_ref_vector soft(m);
         for (unsigned k = 1; k <= min_cardinality; ++k) {
             auto p_k = m.mk_fresh_const("p", m.mk_bool_sort());
+            // TODO: non-deterministic parameter evaluation
             soft.push_back(m.mk_ite(p_k, a.mk_int(1), a.mk_int(0)));
             for (auto c : cardinalities)
                 // p_k => c >= k

src/qe/mbp/mbp_arith.cpp

@@ -577,6 +577,7 @@ namespace mbp {
                 case opt::t_le: t = a.mk_le(t, s); break;
                 case opt::t_eq: t = a.mk_eq(t, s); break;
                 case opt::t_divides:
+                    // TODO: non-deterministic parameter evaluation
                     t = a.mk_eq(a.mk_mod(t, a.mk_int(r.m_mod)), a.mk_int(0));
                     break;
                 default:

src/qe/mbp/mbp_arrays.cpp

@@ -866,6 +866,7 @@ namespace mbp {
             SASSERT(xs.size() == ys.size() && !xs.empty());
             expr_ref result(mk_lt(xs.back(), ys.back()), m);
             for (unsigned i = xs.size()-1; i-- > 0; ) {
+                // TODO: non-deterministic parameter evaluation
                 result = m.mk_or(mk_lt(xs[i], ys[i]),
                                  m.mk_and(m.mk_eq(xs[i], ys[i]), result));
             }

src/qe/mbp/mbp_solve_plugin.cpp

@@ -287,7 +287,9 @@ namespace mbp {
             };
 
             // `first` is a value, different from 0
+            // TODO: non-deterministic parameter evaluation
             res = m.mk_and(m.mk_eq(second, a.mk_idiv(lhs, first)),
+                           // TODO: non-deterministic parameter evaluation
                            m.mk_eq(a.mk_int(0), a.mk_mod(lhs, first)));
 
             return true;

src/qe/nlarith_util.cpp

@@ -389,6 +389,7 @@ namespace nlarith {
         };
 
         expr* mk_abs(expr* e) { 
+            // TODO: non-deterministic parameter evaluation
             return m().mk_ite(mk_lt(e), mk_uminus(e), e);
         }
 
@@ -405,6 +406,7 @@ namespace nlarith {
             }
             else {
                 expr* half = A.mk_numeral(rational(1,2), false);
+                // TODO: non-deterministic parameter evaluation
                 result = A.mk_div(mk_add(s.m_a, mk_mul(num(s.m_b), A.mk_power(mk_abs(s.m_c), half))), s.m_d);
             }
             return result;
@@ -439,10 +441,13 @@ namespace nlarith {
             expr* result = to_expr(s);
             if (is_strict(cmp)) {
                 if (p.m_a == z()) {
+                    // TODO: non-deterministic parameter evaluation
+                    // TODO: non-deterministic parameter evaluation
                     result = mk_add(result, mk_mul(mk_epsilon(), m().mk_ite(mk_lt(p.m_b),num(1),num(-1))));
                 }
                 else {
                     if (s.m_b > 0) {
+                        // TODO: non-deterministic parameter evaluation
                         result = mk_add(result, mk_mul(num(-1),mk_epsilon()));
                     }
                     else {
@@ -481,6 +486,7 @@ namespace nlarith {
         }
 
         app* sq1(expr * e) { 
+            // TODO: non-deterministic parameter evaluation
             return mk_add(num(1), sq(e)); 
         }
 
@@ -591,6 +597,7 @@ namespace nlarith {
             app_ref  t1(m()), a2(m()), d(m());
             expr_ref cond(m()), t2(m()), branch(m());
             expr_ref_vector es(m()), subst(m());
+            // TODO: non-deterministic parameter evaluation
             d = mk_sub(mk_mul(b,b), mk_mul(num(4), a, c));
             a2 = mk_mul(a, num(2));            
 
@@ -1054,8 +1061,13 @@ namespace nlarith {
                    r = I.mk_lt(ad);
                 }
                 else {
+                    // TODO: non-deterministic parameter evaluation
                     aabbc = I.mk_sub(I.mk_mul(a,a), I.mk_mul(b,b,c));
+                    // TODO: non-deterministic parameter evaluation
+                    // TODO: non-deterministic parameter evaluation
                     r = I.mk_or(I.mk_and(I.mk_lt(ad), I.mk_gt(aabbc)),
+                                // TODO: non-deterministic parameter evaluation
+                                // TODO: non-deterministic parameter evaluation
                                 I.mk_and(I.mk_le(bd), I.mk_or(I.mk_lt(ad), I.mk_lt(aabbc))));
                 }
             }
@@ -1071,7 +1083,9 @@ namespace nlarith {
                     r = I.mk_eq(a);
                 }
                 else {
+                    // TODO: non-deterministic parameter evaluation
                     aabbc = I.mk_sub(I.mk_mul(a, a), I.mk_mul(b, b, c));
+                    // TODO: non-deterministic parameter evaluation
                     r = I.mk_and(I.mk_le(I.mk_mul(a, b)), I.mk_eq(aabbc));
                 }
             }
@@ -1091,8 +1105,12 @@ namespace nlarith {
                     r = I.mk_le(ad);
                 }
                 else {
+                    // TODO: non-deterministic parameter evaluation
                     aabbc = I.mk_sub(I.mk_mul(a, a), I.mk_mul(b, b, c));
+                    // TODO: non-deterministic parameter evaluation
+                    // TODO: non-deterministic parameter evaluation
                     r = I.mk_or(I.mk_and(I.mk_le(ad), I.mk_ge(aabbc)),
+                                // TODO: non-deterministic parameter evaluation
                                 I.mk_and(I.mk_le(bd), I.mk_le(aabbc)));
                 }
             }
@@ -1203,6 +1221,7 @@ namespace nlarith {
                     return e;
                 }
                 else {
+                    // TODO: non-deterministic parameter evaluation
                     return I.mk_or(e, I.mk_and(I.mk_eq(t), mk_lt(p, i)));
                 }            
             }
@@ -1233,6 +1252,7 @@ namespace nlarith {
                     return e;
                 }
                 else {
+                    // TODO: non-deterministic parameter evaluation
                     return I.mk_or(e, I.mk_and(I.mk_eq(t), mk_lt(p, i)));
                 }            
             }
@@ -1311,7 +1331,9 @@ namespace nlarith {
                 // = 
                 //   (d*dr*p[i] + a*ar + b*br*c + (a*br + ar*b)*sqrt(c))/d*dr
                 // 
+                // TODO: non-deterministic parameter evaluation
                 app_ref tmp1(mk_add(mk_mul(d, dr, p[i]), mk_mul(a, ar), mk_mul(b, br, c)), m());
+                // TODO: non-deterministic parameter evaluation
                 br = mk_add(mk_mul(a, br), mk_mul(ar, b));
                 dr = mk_mul(d, dr);
                 ar = tmp1;

src/qe/nlqsat.cpp

@@ -656,6 +656,7 @@ namespace qe {
                     expr_ref den_is0(m.mk_eq(divs[i].den, arith.mk_real(0)), m);
                     paxioms.push_back(m.mk_or(den_is0, m.mk_eq(divs[i].num, arith.mk_mul(divs[i].den, divs[i].name))));
                     for (unsigned j = i + 1; j < divs.size(); ++j) {
+                        // TODO: non-deterministic parameter evaluation
                         paxioms.push_back(m.mk_or(m.mk_not(m.mk_eq(divs[i].den, divs[j].den)),
                                                   m.mk_not(m.mk_eq(divs[i].num, divs[j].num)), 
                                                   m.mk_eq(divs[i].name, divs[j].name)));
@@ -665,6 +666,7 @@ namespace qe {
                 expr_ref v0(m.mk_var(0, arith.mk_real()), m);
                 expr_ref v1(m.mk_var(1, arith.mk_real()), m);
                 for (auto const& p : divs) {
+                    // TODO: non-deterministic parameter evaluation
                     body = m.mk_ite(m.mk_and(m.mk_eq(v0, p.num), m.mk_eq(v1, p.den)), p.name, body);
                 }
                 m_div_mc->add(arith.mk_div0(), body);

src/qe/qe_arith_plugin.cpp

@@ -468,6 +468,7 @@ namespace qe {
 
         // ax + t = 0
         void mk_eq(rational const& a, app* x, expr* t, expr_ref& result) {
+            // TODO: non-deterministic parameter evaluation
             result = m_arith.mk_eq(mk_add(mk_mul(a, x), t), mk_zero(x));
         }
 

src/sat/smt/arith_axioms.cpp

@@ -262,6 +262,7 @@ namespace arith {
         // x mod 2^{i + 1} >= 2^i means the i'th bit is 1.
         auto bitof = [&](expr* x, unsigned i) { 
             expr_ref r(m);
+            // TODO: non-deterministic parameter evaluation
             r = a.mk_ge(a.mk_mod(x, a.mk_int(rational::power_of_two(i+1))), a.mk_int(rational::power_of_two(i)));
             return mk_literal(r);
         };
@@ -390,8 +391,11 @@ namespace arith {
             // y >= sz & x >= 2^{sz-1} => n = -1
             // y = 0 => n = x
             auto signx = mk_literal(a.mk_ge(x, a.mk_int(N/2)));
+            // TODO: non-deterministic parameter evaluation
             add_clause(~mk_literal(a.mk_ge(a.mk_mod(y, a.mk_int(N)), a.mk_int(sz))), signx, mk_literal(m.mk_eq(n, a.mk_int(0))));
+            // TODO: non-deterministic parameter evaluation
             add_clause(~mk_literal(a.mk_ge(a.mk_mod(y, a.mk_int(N)), a.mk_int(sz))), ~signx, mk_literal(m.mk_eq(n, a.mk_int(N-1))));
+            // TODO: non-deterministic parameter evaluation
             add_clause(~mk_literal(a.mk_eq(a.mk_mod(y, a.mk_int(N)), a.mk_int(0))), mk_literal(m.mk_eq(n, x)));            
         }
         else

src/sat/smt/q_solver.cpp

@@ -341,6 +341,7 @@ namespace q {
         }
         if (m.is_not(arg, z) && m.is_iff(z, x, y) && is_literal(x) && is_literal(y)) {
             e1 = m.mk_or(x, y);
+            // TODO: non-deterministic parameter evaluation
             e2 = m.mk_or(mk_not(m, x), mk_not(m, y));
             return true;
         }

src/sat/tactic/sat2goal.cpp

@@ -253,6 +253,7 @@ struct sat2goal::imp {
         s.collect_bin_clauses(bin_clauses, m_learned, false);
         for (sat::solver::bin_clause const& bc : bin_clauses) {
             checkpoint();
+            // TODO: non-deterministic parameter evaluation
             r.assert_expr(m.mk_or(lit2expr(mc, bc.first), lit2expr(mc, bc.second)));
         }
         // collect clauses

src/smt/seq_regex.cpp

@@ -396,6 +396,7 @@ namespace smt {
         else if (re().is_empty(r2))
             r = r1;
         else 
+            // TODO: non-deterministic parameter evaluation
             r = re().mk_union(re().mk_diff(r1, r2), re().mk_diff(r2, r1));
         rewrite(r);
         return r;

src/smt/theory_array_base.cpp

@@ -360,6 +360,7 @@ namespace smt {
         ctx.mark_as_relevant(sel1_eq_sel2);
         if (m.has_trace_stream()) {
             app_ref body(m);
+            // TODO: non-deterministic parameter evaluation
             body = m.mk_implies(m.mk_not(ctx.bool_var2expr(n1_eq_n2.var())), m.mk_not(ctx.bool_var2expr(sel1_eq_sel2.var())));
             log_axiom_instantiation(body);
         }

src/smt/theory_bv.cpp

@@ -241,6 +241,8 @@ namespace smt {
         expr_ref eq(m.mk_eq(e1, e2), m);
         literal l       = ~mk_literal(eq);
         std::function<expr*(void)> logfn = [&]() {
+            // TODO: non-deterministic parameter evaluation
+            // TODO: non-deterministic parameter evaluation
             return m.mk_implies(m.mk_eq(mk_bit2bool(e1, idx), m.mk_not(mk_bit2bool(e2, idx))), m.mk_not(eq));
         };
         scoped_trace_stream ts(*this, logfn);
@@ -456,6 +458,7 @@ namespace smt {
             e2 = mk_bit2bool(o2, i);
             literal eq = mk_eq(e1, e2, true);
             std::function<expr*()> logfn = [&]() {
+                // TODO: non-deterministic parameter evaluation
                 return m.mk_implies(m.mk_not(ctx.bool_var2expr(eq.var())), m.mk_not(ctx.bool_var2expr(oeq.var())));
             };
             scoped_trace_stream st(*this, logfn);

src/smt/theory_char.cpp

@@ -259,6 +259,7 @@ namespace smt {
         unsigned p = 0;
         arith_util a(m);
         for (auto b : bits) {
+            // TODO: non-deterministic parameter evaluation
             sum.push_back(m.mk_ite(b, a.mk_int(1 << p), a.mk_int(0)));
             p++;
         }

src/smt/theory_datatype.cpp

@@ -247,6 +247,7 @@ namespace smt {
             assert_eq_axiom(arg, acc_own, is_con); 
         }
         // update_field is identity if 'n' is not created by a matching constructor.        
+        // TODO: non-deterministic parameter evaluation
         app_ref imp(m.mk_implies(m.mk_not(rec_app), m.mk_eq(n->get_expr(), arg1)), m);
         assert_eq_axiom(n, arg1, ~is_con);
 

src/smt/theory_dl.cpp

@@ -252,6 +252,7 @@ namespace smt {
             get_rep(s, r, v);
             app_ref lt(m()), le(m());
             lt = u().mk_lt(x,y);
+            // TODO: non-deterministic parameter evaluation
             le = b().mk_ule(m().mk_app(r,y),m().mk_app(r,x)); 
             if (m().has_trace_stream()) {
                 app_ref body(m());

src/smt/theory_lra.cpp

@@ -2569,6 +2569,7 @@ public:
             if (ctx().get_assignment(eq) == l_true)
                 return true;            
             ctx().mk_th_axiom(get_id(), ~th.mk_eq(y, a.mk_int(k), false), eq);
+            // TODO: non-deterministic parameter evaluation
             IF_VERBOSE(2, verbose_stream() << "shl: " << mk_bounded_pp(n, m) << " " << valn << " := " << valx << " << " << valy << "\n");
             return false;
         }
@@ -2694,8 +2695,11 @@ public:
             
         for (api_bound* other : bounds) {
             if (other == &b) continue;
+            // TODO: non-deterministic parameter evaluation
             if (b.get_lit() == other->get_lit()) continue;
+            // TODO: non-deterministic parameter evaluation
             lp_api::bound_kind kind2 = other->get_bound_kind();
+            // TODO: non-deterministic parameter evaluation
             rational const& k2 = other->get_value();
             if (k1 == k2 && kind1 == kind2) {
                 // the bounds are equivalent.
@@ -3770,6 +3774,7 @@ public:
         }
         solutions.shrink(j);
 
+        // TODO: non-deterministic parameter evaluation
         expr_ref term(m), guard(m);
         vector<lp::lar_solver::solution> sols;
         lp().solve_for(vars, sols);

src/smt/theory_special_relations.cpp

@@ -803,6 +803,7 @@ namespace smt {
         r.pop(1);
         fi->set_else(arith.mk_numeral(rational(0), true));
         mg.get_model().register_decl(fn, fi);
+        // TODO: non-deterministic parameter evaluation
         result = arith.mk_le(m.mk_app(fn,m.mk_var(0, *ty)), m.mk_app(fn, m.mk_var(1, *ty)));
         return result;
     }
@@ -823,6 +824,7 @@ namespace smt {
         }
         fi->set_else(arith.mk_numeral(rational(0), true));
         mg.get_model().register_decl(fn, fi);
+        // TODO: non-deterministic parameter evaluation
         result = m.mk_eq(m.mk_app(fn, m.mk_var(0, *ty)), m.mk_app(fn, m.mk_var(1, *ty)));
         return result;
     }
@@ -848,7 +850,9 @@ namespace smt {
         hifi->set_else(arith.mk_numeral(rational(0), true));
         mg.get_model().register_decl(lofn, lofi);
         mg.get_model().register_decl(hifn, hifi);
+        // TODO: non-deterministic parameter evaluation
         result = m.mk_and(arith.mk_le(m.mk_app(lofn, m.mk_var(0, *ty)), m.mk_app(lofn, m.mk_var(1, *ty))),
+                          // TODO: non-deterministic parameter evaluation
                           arith.mk_le(m.mk_app(hifn, m.mk_var(1, *ty)), m.mk_app(hifn, m.mk_var(0, *ty))));
         return result;
     }
@@ -923,8 +927,10 @@ namespace smt {
             
             expr* x = xV, *S = SV;
             expr_ref mem_body(m);
+            // TODO: non-deterministic parameter evaluation
             mem_body = m.mk_ite(m.mk_app(is_nil, S), 
                                 F,
+                                // TODO: non-deterministic parameter evaluation
                                 m.mk_ite(m.mk_eq(m.mk_app(hd, S), x), 
                                          T,
                                          m.mk_app(memf, x, m.mk_app(tl, S))));            
@@ -947,6 +953,8 @@ namespace smt {
             var_ref SV(m.mk_var(1, listS), m);
             var_ref tupV(m.mk_var(0, tup), m);
             expr* a = aV, *b = bV, *A = AV, *S = SV, *t = tupV;
+            // TODO: non-deterministic parameter evaluation
+            // TODO: non-deterministic parameter evaluation
             next_body = m.mk_ite(m.mk_and(m.mk_app(memf, a, A), m.mk_not(m.mk_app(memf, b, S))), 
                                  m.mk_app(pair, m.mk_app(cons, b, m.mk_app(fst, t)), m.mk_app(cons, b, m.mk_app(snd, t))),
                                  t);
@@ -981,7 +989,9 @@ namespace smt {
             expr_ref Ap(m.mk_app(fst, connected_body.get()), m);
             expr_ref Sp(m.mk_app(snd, connected_body.get()), m);
 
+            // TODO: non-deterministic parameter evaluation
             connected_body = m.mk_ite(m.mk_eq(Ap, nilc), F, 
+                                      // TODO: non-deterministic parameter evaluation
                                       m.mk_ite(m.mk_app(memf, dst, Ap), T,
                                                m.mk_app(connectedf, Ap, dst, Sp)));
             

src/tactic/aig/aig.cpp

@@ -879,9 +879,11 @@ struct aig_manager::imp {
             }
             expr * r;
             if (m.is_not_eq(t, e)) {
+                // TODO: non-deterministic parameter evaluation
                 r = ast_mng.mk_iff(get_cached(c), get_cached(t));
             }
             else { 
+                // TODO: non-deterministic parameter evaluation
                 r = ast_mng.mk_ite(get_cached(c), get_cached(t), get_cached(e));
             }
             cache_result(n, r);

src/tactic/arith/bv2real_rewriter.cpp

@@ -443,9 +443,11 @@ bool bv2real_rewriter::mk_le(expr* s, expr* t, bool is_pos, bool is_neg, expr_re
         expr_ref gt_proxy(m().mk_not(le_proxy), m());
         expr_ref s2_is_nonpos(m_bv.mk_sle(s2, m_bv.mk_numeral(rational(0), s2_size)), m());
         
+        // TODO: non-deterministic parameter evaluation
         expr_ref under(u().mk_bv_add(u().mk_bv_mul(rational(4), s1), u().mk_bv_mul(rational(5), s2)), m());
         expr_ref z1(m_bv.mk_numeral(rational(0), m_bv.get_bv_size(under)), m());
         expr_ref le_under(m_bv.mk_sle(under, z1), m());
+        // TODO: non-deterministic parameter evaluation
         expr_ref over(u().mk_bv_add(u().mk_bv_mul(rational(2), s1), u().mk_bv_mul(rational(3), s2)), m());
         expr_ref z2(m_bv.mk_numeral(rational(0), m_bv.get_bv_size(over)), m());
         expr_ref le_over(m_bv.mk_sle(over, z2), m());
@@ -462,8 +464,10 @@ bool bv2real_rewriter::mk_le(expr* s, expr* t, bool is_pos, bool is_neg, expr_re
         // predicate may occur in negative polarity.
         if (is_neg) {
             // s1 + s2*sqrt(2) > 0  <== s2 > 0 & s1 + s2*(5/4) > 0;  4*s1 + 5*s2 > 0
+            // TODO: non-deterministic parameter evaluation
             expr* e3 = m().mk_implies(m().mk_and(gt_proxy, m().mk_not(s2_is_nonpos)), m().mk_not(le_under));
             // s1 + s2*sqrt(2) > 0  <== s2 <= 0 & s1 + s2*(3/2) > 0 <=> 2*s1 + 3*s2 > 0
+            // TODO: non-deterministic parameter evaluation
             expr* e4 = m().mk_implies(m().mk_and(gt_proxy, s2_is_nonpos), m().mk_not(le_over));
             u().add_side_condition(e3);
             u().add_side_condition(e4);
@@ -543,7 +547,9 @@ br_status bv2real_rewriter::mk_le(expr * s, expr * t, expr_ref & result) {
         expr* ge  = m_bv.mk_sle(t22, t12);
         expr* le  = m_bv.mk_sle(t12, t22);
         expr* e1  = m().mk_or(gz1, gz2);
+        // TODO: non-deterministic parameter evaluation
         expr* e2  = m().mk_or(m().mk_not(gz1), m().mk_not(lz2), ge);
+        // TODO: non-deterministic parameter evaluation
         expr* e3  = m().mk_or(m().mk_not(gz2), m().mk_not(lz1), le);
         result    = m().mk_and(e1, e2, e3);
         TRACE(bv2real_rewriter, tout << "\n";);
@@ -587,6 +593,7 @@ br_status bv2real_rewriter::mk_eq(expr * s, expr * t, expr_ref & result) {
         u().align_divisors(s1, s2, t1, t2, d1, d2);
         u().align_sizes(s1, t1);
         u().align_sizes(s2, t2);
+        // TODO: non-deterministic parameter evaluation
         result = m().mk_and(m().mk_eq(s1, t1), m().mk_eq(s2, t2));
         return BR_DONE;
     }
@@ -650,7 +657,9 @@ br_status bv2real_rewriter::mk_mul(expr* s, expr* t, expr_ref& result) {
     if (u().is_bv2real(s, s1, s2, d1, r1) && u().is_bv2real(t, t1, t2, d2, r2) && r1 == r2) {
         // s1*t1 + r1*(s2*t2) + (s1*t2 + s2*t2)*r1
         expr_ref u1(m()), u2(m());
+        // TODO: non-deterministic parameter evaluation
         u1 = u().mk_bv_add(u().mk_bv_mul(s1, t1), u().mk_bv_mul(r1, u().mk_bv_mul(t2, s2)));
+        // TODO: non-deterministic parameter evaluation
         u2 = u().mk_bv_add(u().mk_bv_mul(s1, t2), u().mk_bv_mul(s2, t1));
         rational tmp = d1*d2;
         if (u().mk_bv2real(u1, u2, tmp, r1, result)) {

src/tactic/arith/factor_tactic.cpp

@@ -63,6 +63,7 @@ class factor_tactic : public tactic {
                 m_expr2poly.to_expr(fs[i], true, arg);
                 args.push_back(arg);
             }
+            // TODO: non-deterministic parameter evaluation
             result = m.mk_eq(mk_mul(args.size(), args.data()), mk_zero_for(arg));
         }
 

src/tactic/arith/lia2card_tactic.cpp

@@ -260,6 +260,7 @@ public:
             return m_pb.mk_eq(sz, weights, args, w);
         }
         else {
+            // TODO: non-deterministic parameter evaluation
             return m.mk_and(mk_ge(sz, weights, args, w), mk_le(sz, weights, args, w));
         }
     }

src/tactic/arith/pb2bv_tactic.cpp

@@ -623,6 +623,7 @@ private:
                 if (is_uninterp_const(lhs) && is_uninterp_const(rhs)) {
                     add_bounds_dependencies(lhs);
                     add_bounds_dependencies(rhs);
+                    // TODO: non-deterministic parameter evaluation
                     r = m.mk_iff(mon_lit2lit(lit(lhs, false)),
                                  mon_lit2lit(lit(rhs, !pos)));
                     return;
@@ -807,6 +808,7 @@ private:
                     for (unsigned i = 0; i < sz; i += 2) {
                         app * x_i = to_app(m_p[i].m_lit.var());
                         app * y_i = to_app(m_p[i+1].m_lit.var());
+                        // TODO: non-deterministic parameter evaluation
                         eqs.push_back(m.mk_eq(int2lit(x_i), int2lit(y_i)));
                     }
                     m_b_rw.mk_and(eqs.size(), eqs.data(), r);

src/tactic/arith/purify_arith_tactic.cpp

@@ -331,12 +331,14 @@ struct purify_arith_proc {
             expr * x = args[0];
             expr * y = args[1];
             // y = 0 \/ y*k = x
+            // TODO: non-deterministic parameter evaluation
             push_cnstr(OR(EQ(y, mk_real_zero()),
                           EQ(u().mk_mul(y, k), x)));
             push_cnstr_pr(result_pr);
             rational r;
             if (complete()) {
                 // y != 0 \/ k = div-0(x)
+                // TODO: non-deterministic parameter evaluation
                 push_cnstr(OR(NOT(EQ(y, mk_real_zero())),
                               EQ(k, u().mk_div(x, mk_real_zero()))));
                 push_cnstr_pr(result_pr);
@@ -375,6 +377,7 @@ struct purify_arith_proc {
             //       y < 0 implies k2 < -y  --->  y >= 0 \/ k2 < -y
             //     
             expr * zero = mk_int_zero();
+            // TODO: non-deterministic parameter evaluation
             push_cnstr(OR(EQ(y, zero), EQ(x, u().mk_add(u().mk_mul(k1, y), k2))));
             push_cnstr_pr(result_pr, mod_pr);
 
@@ -389,9 +392,11 @@ struct purify_arith_proc {
 
             rational r;
             if (complete() && (!u().is_numeral(y, r) || r.is_zero())) {
+                // TODO: non-deterministic parameter evaluation
                 push_cnstr(OR(NOT(EQ(y, zero)), EQ(k1, u().mk_idiv(x, zero))));
                 push_cnstr_pr(result_pr);
 
+                // TODO: non-deterministic parameter evaluation
                 push_cnstr(OR(NOT(EQ(y, zero)), EQ(k2, u().mk_mod(x, zero))));
                 push_cnstr_pr(mod_pr);
             }
@@ -463,8 +468,10 @@ struct purify_arith_proc {
                 }
 
                 // (^ x 0) --> k  |  x != 0 implies k = 1,   x = 0 implies k = 0^0 
+                // TODO: non-deterministic parameter evaluation
                 push_cnstr(OR(EQ(x, zero), EQ(k, one)));
                 push_cnstr_pr(result_pr);
+                // TODO: non-deterministic parameter evaluation
                 push_cnstr(OR(NOT(EQ(x, zero)), EQ(k, p0)));
                 push_cnstr_pr(result_pr);
             }
@@ -482,6 +489,7 @@ struct purify_arith_proc {
                     SASSERT(n.is_even());
                     // (^ x (/ 1 n)) --> k  |  x >= 0 implies (x = k^n and k >= 0), x < 0 implies k = neg-root(x, n)   
                     // when n is even
+                    // TODO: non-deterministic parameter evaluation
                     push_cnstr(OR(NOT(u().mk_ge(x, zero)),
                                   AND(EQ(x, u().mk_power(k, u().mk_numeral(n, false))),
                                       u().mk_ge(k, zero))));
@@ -600,8 +608,11 @@ struct purify_arith_proc {
             expr * pi2   = u().mk_mul(u().mk_numeral(rational(1,2), false), u().mk_pi());
             expr * mpi2  = u().mk_mul(u().mk_numeral(rational(-1,2), false), u().mk_pi());
             // -1 <= x <= 1 implies sin(k) = x, -pi/2 <= k <= pi/2
+            // TODO: non-deterministic parameter evaluation
+            // TODO: non-deterministic parameter evaluation
             push_cnstr(OR(OR(NOT(u().mk_ge(x, mone)),
                              NOT(u().mk_le(x, one))),
+                          // TODO: non-deterministic parameter evaluation
                           AND(EQ(x, u().mk_sin(k)),
                               AND(u().mk_ge(k, mpi2),
                                   u().mk_le(k, pi2)))));
@@ -642,8 +653,11 @@ struct purify_arith_proc {
             expr * pi    = u().mk_pi();
             expr * zero  = u().mk_numeral(rational(0), false);
             // -1 <= x <= 1 implies cos(k) = x, 0 <= k <= pi
+            // TODO: non-deterministic parameter evaluation
+            // TODO: non-deterministic parameter evaluation
             push_cnstr(OR(OR(NOT(u().mk_ge(x, mone)),
                              NOT(u().mk_le(x, one))),
+                          // TODO: non-deterministic parameter evaluation
                           AND(EQ(x, u().mk_cos(k)),
                               AND(u().mk_ge(k, zero),
                                   u().mk_le(k, pi)))));
@@ -678,6 +692,7 @@ struct purify_arith_proc {
             // tan(k) = x, -pi/2 < k < pi/2
             expr * pi2   = u().mk_mul(u().mk_numeral(rational(1,2), false), u().mk_pi());
             expr * mpi2  = u().mk_mul(u().mk_numeral(rational(-1,2), false), u().mk_pi());
+            // TODO: non-deterministic parameter evaluation
             push_cnstr(AND(EQ(x, u().mk_tan(k)),
                            AND(u().mk_gt(k, mpi2),
                                u().mk_lt(k, pi2))));
@@ -804,7 +819,9 @@ struct purify_arith_proc {
             auto const& p1 = divs[i];
             for (unsigned j = i + 1; j < divs.size(); ++j) {
                 auto const& p2 = divs[j];
+                // TODO: non-deterministic parameter evaluation
                 m_goal.assert_expr(m().mk_implies(
+                                       // TODO: non-deterministic parameter evaluation
                                        m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)), 
                                        m().mk_eq(p1.d, p2.d)));
             }
@@ -813,7 +830,9 @@ struct purify_arith_proc {
             auto const& p1 = mods[i];
             for (unsigned j = i + 1; j < mods.size(); ++j) {
                 auto const& p2 = mods[j];
+                // TODO: non-deterministic parameter evaluation
                 m_goal.assert_expr(m().mk_implies(
+                                       // TODO: non-deterministic parameter evaluation
                                        m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)), 
                                        m().mk_eq(p1.d, p2.d)));
             }
@@ -822,7 +841,9 @@ struct purify_arith_proc {
             auto const& p1 = idivs[i];
             for (unsigned j = i + 1; j < idivs.size(); ++j) {
                 auto const& p2 = idivs[j];
+                // TODO: non-deterministic parameter evaluation
                 m_goal.assert_expr(m().mk_implies(
+                                       // TODO: non-deterministic parameter evaluation
                                        m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)), 
                                        m().mk_eq(p1.d, p2.d)));
             }
@@ -843,6 +864,7 @@ struct purify_arith_proc {
                 expr_ref v0(m().mk_var(0, u().mk_real()), m());
                 expr_ref v1(m().mk_var(1, u().mk_real()), m());
                 for (auto const& p : divs) {
+                    // TODO: non-deterministic parameter evaluation
                     body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body);
                 }
                 fmc->add(u().mk_div0(), body);
@@ -852,6 +874,7 @@ struct purify_arith_proc {
                 expr_ref v0(m().mk_var(0, u().mk_int()), m());
                 expr_ref v1(m().mk_var(1, u().mk_int()), m());
                 for (auto const& p : mods) {
+                    // TODO: non-deterministic parameter evaluation
                     body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body);
                 }
                 
@@ -864,6 +887,7 @@ struct purify_arith_proc {
                 expr_ref v0(m().mk_var(0, u().mk_int()), m());
                 expr_ref v1(m().mk_var(1, u().mk_int()), m());
                 for (auto const& p : idivs) {
+                    // TODO: non-deterministic parameter evaluation
                     body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body);
                 }
                 fmc->add(u().mk_idiv0(), body);
@@ -881,6 +905,7 @@ struct purify_arith_proc {
             for (auto const& kv : m_sin_cos) {
                 emc->add(kv.m_key->get_decl(), 
                             m().mk_ite(u().mk_ge(kv.m_value.first, mk_real_zero()), u().mk_acos(kv.m_value.second), 
+                                       // TODO: non-deterministic parameter evaluation
                                        u().mk_add(u().mk_acos(u().mk_uminus(kv.m_value.second)), u().mk_pi())));
             }
 

src/tactic/bv/bv1_blaster_tactic.cpp

@@ -142,6 +142,7 @@ class bv1_blaster_tactic : public tactic {
             unsigned i = bits1.size();
             while (i > 0) {
                 --i;
+                // TODO: non-deterministic parameter evaluation
                 new_eqs.push_back(m().mk_eq(bits1[i], bits2[i]));
             }
             result = mk_and(m(), new_eqs.size(), new_eqs.data());
@@ -156,6 +157,7 @@ class bv1_blaster_tactic : public tactic {
             bit_buffer new_ites;
             unsigned num = t_bits.size();
             for (unsigned i = 0; i < num; i++)             
+                // TODO: non-deterministic parameter evaluation
                 new_ites.push_back(t_bits[i] == e_bits[i] ? t_bits[i] : m().mk_ite(c, t_bits[i], e_bits[i]));
             result = butil().mk_concat(new_ites.size(), new_ites.data());
         }
@@ -216,6 +218,7 @@ class bv1_blaster_tactic : public tactic {
             bit_buffer new_bits;
             unsigned num = bits1.size();
             for (unsigned i = 0; i < num; i++) {
+                // TODO: non-deterministic parameter evaluation
                 new_bits.push_back(m().mk_ite(m().mk_eq(bits1[i], bits2[i]), m_bit0, m_bit1));
             }
             result = butil().mk_concat(new_bits.size(), new_bits.data());

src/tactic/bv/bvarray2uf_rewriter.cpp

@@ -149,6 +149,7 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
             var_ref x(m_manager.mk_var(0, sorts[0]), m_manager);
 
             expr_ref body(m_manager);
+            // TODO: non-deterministic parameter evaluation
             body = m_manager.mk_eq(m_manager.mk_app(f_t, x.get()), m_manager.mk_app(f_s, x.get()));
 
             result = m_manager.mk_forall(1, sorts, names, body);
@@ -295,6 +296,7 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
                         new_args.push_back(m_manager.mk_app(ss[i].get(), x.get()));
 
                     expr_ref body(m_manager);
+                    // TODO: non-deterministic parameter evaluation
                     body = m_manager.mk_eq(m_manager.mk_app(f_t, x.get()),
                                            m_manager.mk_app(map_f, num, new_args.data()));
 
@@ -330,7 +332,9 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
                         var_ref x(m_manager.mk_var(0, sorts[0]), m_manager);
 
                         expr_ref body(m_manager);
+                        // TODO: non-deterministic parameter evaluation
                         body = m_manager.mk_or(m_manager.mk_eq(x, i),
+                                               // TODO: non-deterministic parameter evaluation
                                                m_manager.mk_eq(m_manager.mk_app(f_t, x.get()),
                                                                m_manager.mk_app(f_s, x.get())));
 

src/tactic/fd_solver/enum2bv_solver.cpp

@@ -178,6 +178,7 @@ public:
                 expr_ref head(m);
                 ptr_vector<func_decl> const& enums = *dt.get_datatype_constructors(f->get_range());
                 if (enums.size() > num.get_unsigned()) {
+                    // TODO: non-deterministic parameter evaluation
                     head = m.mk_eq(m.mk_const(f), m.mk_const(enums[num.get_unsigned()]));
                     consequences[i] = m.mk_implies(a, head);
                 }

src/tactic/fd_solver/smtfd_solver.cpp

@@ -314,12 +314,14 @@ namespace smtfd {
                     }
                     family_id fid = a->get_family_id();
                     if (m.is_eq(a)) {
+                        // TODO: non-deterministic parameter evaluation
                         r = m.mk_eq(m_args.get(0), m_args.get(1));
                     }
                     else if (m.is_distinct(a)) {
                         r = m.mk_distinct(m_args.size(), m_args.data());
                     }
                     else if (m.is_ite(a)) {
+                        // TODO: non-deterministic parameter evaluation
                         r = m.mk_ite(m_args.get(0), m_args.get(1), m_args.get(2));
                     }
                     else if (bvfid == fid || bfid == fid || pbfid == fid) {
@@ -1157,6 +1159,7 @@ namespace smtfd {
             expr_ref a1(m_autil.mk_select(args), m);
             args[0] = b;
             expr_ref b1(m_autil.mk_select(args), m);
+            // TODO: non-deterministic parameter evaluation
             expr_ref ext(m.mk_iff(m.mk_eq(a1, b1), m.mk_eq(a, b)), m);
             if (!m.is_true(eval_abs(ext))) {
                 TRACE(smtfd, tout << mk_bounded_pp(a, m, 2) << " " << mk_bounded_pp(b, m, 2) << "\n";);

src/util/sorting_network.h

@@ -343,6 +343,7 @@ Notes:
                         return mk_not(out[k]);
                     }
                     else {
+                        // TODO: non-deterministic parameter evaluation
                         return mk_min(out[k-1], mk_not(out[k]));
                     }
                 case sorting_network_encoding::unate_at_most:
@@ -384,6 +385,7 @@ Notes:
         }
 
         literal eq(unsigned k, unsigned n, unsigned const* ws, literal const* xs) {
+            // TODO: non-deterministic parameter evaluation
             return mk_and(ge(k, n, ws, xs), le(k, n, ws, xs));
 #if 0
             m_t = EQ;
@@ -479,6 +481,7 @@ Notes:
                 for (unsigned j = last; j-- > 0; ) {
                     // c'[j] <-> (xs[i] & c[j-1]) | c[j]
                     literal c0 = j > 0 ? carry[j-1] : ctx.mk_true();
+                    // TODO: non-deterministic parameter evaluation
                     carry[j] = mk_or(mk_and(xs[i], c0), carry[j]);
                 }
             }
@@ -490,6 +493,7 @@ Notes:
             case GE_FULL:
                 return carry[k-1];
             case EQ:
+                // TODO: non-deterministic parameter evaluation
                 return mk_and(mk_not(carry[k]), carry[k-1]);
             default:
                 UNREACHABLE();
@@ -522,6 +526,7 @@ Notes:
                 // out[i] = c + x[i] + y[i]
                 // c' = c&x[i] | c&y[i] | x[i]&y[i];
                 literal_vector ors; 
+                // TODO: non-deterministic parameter evaluation
                 ors.push_back(mk_and(c,    mk_not(x[i]), mk_not(y[i]))); 
                 ors.push_back(mk_and(x[i], mk_not(c),    mk_not(y[i])));
                 ors.push_back(mk_and(y[i], mk_not(c),    mk_not(x[i])));
@@ -578,7 +583,9 @@ Notes:
                 literal_vector eqs;
                 SASSERT(kvec.size() == out.size());
                 for (unsigned i = 0; i < num_bits; ++i) {
+                    // TODO: non-deterministic parameter evaluation
                     eqs.push_back(mk_or(mk_not(kvec[i]), out[i]));
+                    // TODO: non-deterministic parameter evaluation
                     eqs.push_back(mk_or(kvec[i], mk_not(out[i])));
                 }
                 eqs.push_back(mk_not(ovfl));
@@ -686,6 +693,7 @@ Notes:
             case 1:
                 return ands[0];
             case 2:
+                // TODO: non-deterministic parameter evaluation
                 return mk_min(ands[0], ands[1]);
             default: {
                 return ctx.mk_min(ands.size(), ands.data());