/*++
Copyright (c) 2012 Microsoft Corporation

Module Name:

    sls_tactic.h

Abstract:

    A Stochastic Local Search (SLS) tactic

Author:

    Christoph (cwinter) 2012-02-29

Notes:

--*/
#include<iomanip>
#include"map.h"
#include"nnf.h"
#include"cooperate.h"
#include"ast_smt2_pp.h"
#include"ast_pp.h"
#include"var_subst.h"
#include"model_pp.h"
#include"model_evaluator.h"
#include"solve_eqs_tactic.h"
#include"assertion_set_rewriter.h"
#include"shallow_context_simplifier.h"
#include"elim_uncnstr_tactic.h"
#include"bv_size_reduction_tactic.h"
#include"max_bv_sharing_tactic.h"
#include"simplify_tactic.h"
#include"stopwatch.h"
#include"expr2dot.h"
#include"propagate_values_tactic.h"
#include"sls_tactic.h"

class sls_tactic : public tactic {
    class stats {
    public:
        unsigned        m_restarts;
        stopwatch       m_stopwatch;    
        unsigned        m_full_evals;
        unsigned        m_incr_evals;
        unsigned        m_moves, m_flips, m_incs, m_decs, m_invs;
        stats() :
            m_restarts(0),
            m_full_evals(0),
            m_incr_evals(0),
            m_moves(0),
            m_flips(0),
            m_incs(0),
            m_decs(0),
            m_invs(0) {
                m_stopwatch.reset();
                m_stopwatch.start();
            }
        void reset() {
            m_full_evals = m_flips = m_incr_evals = 0;
            m_stopwatch.reset();
            m_stopwatch.start();
        }
    };    

    struct imp {
        class score_tracker;

        class powers : public u_map<mpz*> {
            unsynch_mpz_manager & m;
        public:
            powers(unsynch_mpz_manager & m) : m(m) {}
            ~powers() {
                for (iterator it = begin(); it != end(); it++) {
                    m.del(*it->m_value);
                    dealloc(it->m_value);
                }
            }

            const mpz & operator()(unsigned n) {
                u_map<mpz*>::iterator it = find_iterator(n);
                if (it != end())
                    return *it->m_value;
                else {
                    mpz * new_obj = alloc(mpz);
                    insert(n, new_obj);
                    m.power(unsynch_mpz_manager::mk_z(2), n, *new_obj);
                    return *new_obj;
                }
            }
        };

        class evaluator {
            ast_manager         & m_manager;
            bv_util             & m_bv_util;
            family_id             m_bv_fid;
            score_tracker       & m_tracker;
            unsynch_mpz_manager & m_mpz_manager;
            mpz                   m_zero, m_one, m_two;
            powers              & m_powers;
        

        public:
            evaluator(ast_manager & m, bv_util & bvu, score_tracker & t, unsynch_mpz_manager & mm, powers & p) : 
                m_manager(m), 
                m_bv_util(bvu), 
                m_tracker(t),
                m_mpz_manager(mm),
                m_zero(m_mpz_manager.mk_z(0)),
                m_one(m_mpz_manager.mk_z(1)),
                m_two(m_mpz_manager.mk_z(2)),
                m_powers(p) {
                m_bv_fid = m_bv_util.get_family_id();
            }

            ~evaluator() {
                m_mpz_manager.del(m_zero);
                m_mpz_manager.del(m_one);
                m_mpz_manager.del(m_two);            
            }        

            void operator()(app * n, mpz & result) {
                func_decl * fd = n->get_decl();            
                unsigned n_args = n->get_num_args();
                expr * const * args = n->get_args(); 
            
                m_mpz_manager.set(result, m_zero);
            
                if (m_manager.is_and(n)) {
                    m_mpz_manager.set(result, m_one);
                    for (unsigned i = 0; i < n_args; i++) {
                        if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result))  {
                            m_mpz_manager.set(result, m_zero);
                            break;
                        }
                    }
                }
                else if (m_manager.is_or(n)) {
                    for (unsigned i = 0; i < n_args; i++) {
                        if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result)) {
                            m_mpz_manager.set(result, m_one);
                            break;
                        }
                    }
                }
                else if (m_manager.is_not(n)) {
                    SASSERT(n_args == 1);
                    const mpz & child = m_tracker.get_value(args[0]);
                    SASSERT(m_mpz_manager.is_one(child) || m_mpz_manager.is_zero(child));                
                    m_mpz_manager.set(result, (m_mpz_manager.is_zero(child)) ? m_one : m_zero);                
                }
                else if (m_manager.is_eq(n)) {
                    SASSERT(n_args >= 2);
                    m_mpz_manager.set(result, m_one);
                    const mpz & first = m_tracker.get_value(args[0]);
                    for (unsigned i = 1; i < n_args; i++) {
                        if (m_mpz_manager.neq(m_tracker.get_value(args[i]), first)) {
                            m_mpz_manager.set(result, m_zero);
                            break;
                        }
                    }
                }
                else if (m_manager.is_distinct(n)) {
                    m_mpz_manager.set(result, m_one);
                    for (unsigned i = 0; i < n_args && m_mpz_manager.is_one(result); i++) {
                        for (unsigned j = i+1; j < n_args && m_mpz_manager.is_one(result); j++) {
                            if (m_mpz_manager.eq(m_tracker.get_value(args[i]), m_tracker.get_value(args[j])))
                                m_mpz_manager.set(result, m_zero);
                        }
                    }
                }
                else if (fd->get_family_id() == m_bv_fid) {
                    bv_op_kind k = static_cast<bv_op_kind>(fd->get_decl_kind());
                    switch(k) {
                    case OP_CONCAT: {
                        SASSERT(n_args >= 2);
                        for (unsigned i = 0; i < n_args; i++) {                        
                            if (i != 0) {
                                const mpz & p = m_powers(m_bv_util.get_bv_size(args[i]));
                                m_mpz_manager.mul(result, p, result);                            
                            }
                            m_mpz_manager.add(result, m_tracker.get_value(args[i]), result);
                        }
                        break;
                    }
                    case OP_EXTRACT: {
                        SASSERT(n_args == 1);
                        const mpz & child = m_tracker.get_value(args[0]);
                        unsigned h = m_bv_util.get_extract_high(n);
                        unsigned l = m_bv_util.get_extract_low(n);
                
                        mpz mask;
                        m_mpz_manager.set(mask, m_powers(h+1));
                        m_mpz_manager.dec(mask);
                        m_mpz_manager.bitwise_and(child, mask, result); // result = [h:0] of child                
                
                        // shift result by l
                        for (; l != 0 ; l--)
                            m_mpz_manager.machine_div(result, m_two, result);

                        m_mpz_manager.del(mask);
                        break;
                    }
                    case OP_BADD: {
                        SASSERT(n_args >= 2);
                        for (unsigned i = 0; i < n_args; i++) {
                            const mpz & next = m_tracker.get_value(args[i]);                    
                            m_mpz_manager.add(result, next, result);
                        }                
                        const mpz & p = m_powers(m_bv_util.get_bv_size(n));                
                        m_mpz_manager.rem(result, p, result);
                        break;
                    }
                    case OP_BSUB: {
                        SASSERT(n_args == 2);
                        const mpz & p = m_powers(m_bv_util.get_bv_size(n));
                        mpz temp;
                        m_mpz_manager.sub(m_tracker.get_value(args[0]), m_tracker.get_value(args[1]), temp);
                        m_mpz_manager.mod(temp, p, result);
                        m_mpz_manager.del(temp);
                        break;
                    }
                    case OP_BMUL: {
                        SASSERT(n_args >= 2);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        for (unsigned i = 1; i < n_args; i++) {
                            const mpz & next = m_tracker.get_value(args[i]);                    
                            m_mpz_manager.mul(result, next, result);
                        }
                        const mpz & p = m_powers(m_bv_util.get_bv_size(n));                    
                        m_mpz_manager.rem(result, p, result);
                        break;
                    }
                    case OP_BNEG: { // 2's complement unary minus
                        SASSERT(n_args == 1);
                        const mpz & child = m_tracker.get_value(args[0]);
                        if (m_mpz_manager.is_zero(child)) {
                            m_mpz_manager.set(result, m_zero);
                        }
                        else {
                            unsigned bv_sz = m_bv_util.get_bv_size(n);
                            m_mpz_manager.bitwise_not(bv_sz, child, result);
                            m_mpz_manager.inc(result); // can't overflow
                        }
                        break;
                    }
                    case OP_BSDIV:
                    case OP_BSDIV0:              
                    case OP_BSDIV_I: {
                        SASSERT(n_args == 2);
                        mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
                        mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
                        SASSERT(m_mpz_manager.is_nonneg(x) && m_mpz_manager.is_nonneg(y));
                        unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
                        const mpz & p = m_powers(bv_sz);
                        const mpz & p_half = m_powers(bv_sz-1);
                        if (x >= p_half) { m_mpz_manager.sub(x, p, x); } 
                        if (y >= p_half) { m_mpz_manager.sub(y, p, y); }

                        if (m_mpz_manager.is_zero(y)) {
                            if (m_mpz_manager.is_neg(x))
                                m_mpz_manager.set(result, m_one);
                            else {
                                m_mpz_manager.set(result, m_powers(m_bv_util.get_bv_size(n)));
                                m_mpz_manager.dec(result);
                            }
                        }
                        else {
                            m_mpz_manager.machine_div(x, y, result);
                        }
                        if (m_mpz_manager.is_neg(result))
                            m_mpz_manager.add(result, p, result);
                        m_mpz_manager.del(x);
                        m_mpz_manager.del(y);                    
                        break;
                    }
                    case OP_BUDIV:
                    case OP_BUDIV0:
                    case OP_BUDIV_I: {
                        SASSERT(n_args == 2);
                        mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
                        mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
                    
                        if (m_mpz_manager.is_zero(y)) {
                            m_mpz_manager.set(result, m_powers(m_bv_util.get_bv_size(n)));
                            m_mpz_manager.dec(result);
                        }
                        else {
                            m_mpz_manager.machine_div(x, y, result);
                        }
                        m_mpz_manager.del(x);
                        m_mpz_manager.del(y);
                        break;
                    }
                    case OP_BSREM: 
                    case OP_BSREM0:
                    case OP_BSREM_I: {
                        SASSERT(n_args == 2);
                        mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
                        mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
                        unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
                        const mpz & p = m_powers(bv_sz);
                        const mpz & p_half = m_powers(bv_sz-1);
                        if (x >= p_half) { m_mpz_manager.sub(x, p, x); } 
                        if (y >= p_half) { m_mpz_manager.sub(y, p, y); }

                        if (m_mpz_manager.is_zero(y)) {                        
                            m_mpz_manager.set(result, x);                        
                        }
                        else {
                            m_mpz_manager.rem(x, y, result);
                        }
                        if (m_mpz_manager.is_neg(result))
                            m_mpz_manager.add(result, p, result);
                        m_mpz_manager.del(x);
                        m_mpz_manager.del(y);
                        break;
                    }
                    case OP_BUREM: 
                    case OP_BUREM0:
                    case OP_BUREM_I: {
                        SASSERT(n_args == 2);
                        mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
                        mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));                    

                        if (m_mpz_manager.is_zero(y)) {
                            m_mpz_manager.set(result, x);                        
                        }
                        else {
                            m_mpz_manager.mod(x, y, result);
                        }
                        m_mpz_manager.del(x);
                        m_mpz_manager.del(y);
                        break;
                    }
                    case OP_BSMOD: 
                    case OP_BSMOD0:
                    case OP_BSMOD_I:{
                        SASSERT(n_args == 2);
                        mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
                        mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
                        unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
                        const mpz & p = m_powers(bv_sz);
                        const mpz & p_half = m_powers(bv_sz-1);
                        if (x >= p_half) { m_mpz_manager.sub(x, p, x); } 
                        if (y >= p_half) { m_mpz_manager.sub(y, p, y); }                    

                        if (m_mpz_manager.is_zero(y))
                            m_mpz_manager.set(result, x);
                        else {
                            bool neg_x = m_mpz_manager.is_neg(x);
                            bool neg_y = m_mpz_manager.is_neg(y);
                            mpz abs_x, abs_y;
                            m_mpz_manager.set(abs_x, x);
                            m_mpz_manager.set(abs_y, y);
                            if (neg_x) m_mpz_manager.neg(abs_x);
                            if (neg_y) m_mpz_manager.neg(abs_y);
                            SASSERT(m_mpz_manager.is_nonneg(abs_x) && m_mpz_manager.is_nonneg(abs_y));

                            m_mpz_manager.mod(abs_x, abs_y, result);

                            if (m_mpz_manager.is_zero(result) || (!neg_x && !neg_y)) {
                                /* Nothing */
                            }
                            else if (neg_x && !neg_y) {
                                m_mpz_manager.neg(result);
                                m_mpz_manager.add(result, y, result);
                            }
                            else if (!neg_x && neg_y) {
                                m_mpz_manager.add(result, y, result);
                            }
                            else {
                                m_mpz_manager.neg(result);                        
                            }

                            m_mpz_manager.del(abs_x);
                            m_mpz_manager.del(abs_y);
                        }

                        if (m_mpz_manager.is_neg(result))
                            m_mpz_manager.add(result, p, result);

                        m_mpz_manager.del(x);
                        m_mpz_manager.del(y);                    
                        break;
                    }
                    case OP_BAND: {
                        SASSERT(n_args >= 2);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        for (unsigned i = 1; i < n_args; i++)
                            m_mpz_manager.bitwise_and(result, m_tracker.get_value(args[i]), result);
                        break;
                    }
                    case OP_BOR: {
                        SASSERT(n_args >= 2);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        for (unsigned i = 1; i < n_args; i++) {
                            m_mpz_manager.bitwise_or(result, m_tracker.get_value(args[i]), result);
                        }
                        break;
                    }
                    case OP_BXOR: {
                        SASSERT(n_args >= 2);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        for (unsigned i = 1; i < n_args; i++)
                            m_mpz_manager.bitwise_xor(result, m_tracker.get_value(args[i]), result);
                        break;
                    }
                    case OP_BNAND: {
                        SASSERT(n_args >= 2);
                        mpz temp;
                        unsigned bv_sz = m_bv_util.get_bv_size(n);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        for (unsigned i = 1; i < n_args; i++) {
                            m_mpz_manager.bitwise_and(result, m_tracker.get_value(args[i]), temp);
                            m_mpz_manager.bitwise_not(bv_sz, temp, result);
                        }
                        m_mpz_manager.del(temp);
                        break;
                    }
                    case OP_BNOR: {
                        SASSERT(n_args >= 2);
                        mpz temp;
                        unsigned bv_sz = m_bv_util.get_bv_size(n);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        for (unsigned i = 1; i < n_args; i++) {
                            m_mpz_manager.bitwise_or(result, m_tracker.get_value(args[i]), temp);
                            m_mpz_manager.bitwise_not(bv_sz, temp, result);
                        }
                        m_mpz_manager.del(temp);
                        break;
                    }
                    case OP_BNOT: {
                        SASSERT(n_args == 1);
                        m_mpz_manager.bitwise_not(m_bv_util.get_bv_size(args[0]), m_tracker.get_value(args[0]), result);
                        break;
                    }
                    case OP_ULT:
                    case OP_ULEQ:
                    case OP_UGT:
                    case OP_UGEQ: {
                        SASSERT(n_args == 2);
                        const mpz & x = m_tracker.get_value(args[0]);
                        const mpz & y = m_tracker.get_value(args[1]);
                        if ((k == OP_ULT  && m_mpz_manager.lt(x, y)) ||
                            (k == OP_ULEQ && m_mpz_manager.le(x, y)) ||
                            (k == OP_UGT  && m_mpz_manager.gt(x, y)) ||
                            (k == OP_UGEQ && m_mpz_manager.ge(x, y)))
                            m_mpz_manager.set(result, m_one);
                        break;
                    }
                    case OP_SLT:
                    case OP_SLEQ: 
                    case OP_SGT:
                    case OP_SGEQ: {
                        SASSERT(n_args == 2);
                        mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
                        mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
                        unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
                        const mpz & p = m_powers(bv_sz);
                        const mpz & p_half = m_powers(bv_sz-1);
                        if (x >= p_half) { m_mpz_manager.sub(x, p, x); } 
                        if (y >= p_half) { m_mpz_manager.sub(y, p, y); } 
                        if ((k == OP_SLT  && m_mpz_manager.lt(x, y)) ||
                            (k == OP_SLEQ && m_mpz_manager.le(x, y)) ||
                            (k == OP_SGT  && m_mpz_manager.gt(x, y)) ||
                            (k == OP_SGEQ && m_mpz_manager.ge(x, y)))
                            m_mpz_manager.set(result, m_one);
                        m_mpz_manager.del(x);
                        m_mpz_manager.del(y);                    
                        break;
                    }
                    case OP_BIT2BOOL: {
                        SASSERT(n_args == 1);
                        const mpz & child = m_tracker.get_value(args[0]);
                        m_mpz_manager.set(result, child);
                        break;
                    }            
                    case OP_BASHR: {
                        SASSERT(n_args == 2);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        mpz first;
                        const mpz & p = m_powers(m_bv_util.get_bv_size(args[0])-1);
                        m_mpz_manager.bitwise_and(result, p, first);
                        mpz shift; m_mpz_manager.set(shift, m_tracker.get_value(args[1]));
                        mpz temp;
                        while (!m_mpz_manager.is_zero(shift)) {
                            m_mpz_manager.machine_div(result, m_two, temp);
                            m_mpz_manager.add(temp, first, result);
                            m_mpz_manager.dec(shift);
                        }
                        m_mpz_manager.del(first);                 
                        m_mpz_manager.del(shift);
                        m_mpz_manager.del(temp);
                        break;
                    }
                    case OP_BLSHR: {
                        SASSERT(n_args == 2);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        mpz shift; m_mpz_manager.set(shift, m_tracker.get_value(args[1]));
                        while (!m_mpz_manager.is_zero(shift)) {
                            m_mpz_manager.machine_div(result, m_two, result);
                            m_mpz_manager.dec(shift);
                        }
                        m_mpz_manager.del(shift);
                        break;
                    }
                    case OP_BSHL: {
                        SASSERT(n_args == 2);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));                
                        mpz shift; m_mpz_manager.set(shift, m_tracker.get_value(args[1]));
                        while (!m_mpz_manager.is_zero(shift)) {
                            m_mpz_manager.mul(result, m_two, result);
                            m_mpz_manager.dec(shift);
                        }
                        const mpz & p = m_powers(m_bv_util.get_bv_size(n));
                        m_mpz_manager.rem(result, p, result);
                        m_mpz_manager.del(shift);                    
                        break;
                    }
                    case OP_SIGN_EXT: {
                        SASSERT(n_args == 1);
                        m_mpz_manager.set(result, m_tracker.get_value(args[0]));
                        break;
                    }
                    default: 
                        NOT_IMPLEMENTED_YET();
                    }
                }
                else {
                    NOT_IMPLEMENTED_YET();
                }            

                TRACE("sls_eval", tout << "(" << fd->get_name();
                                    for (unsigned i = 0; i < n_args; i++)
                                        tout << " " << m_mpz_manager.to_string(m_tracker.get_value(args[i]));
                                    tout << ") ---> " <<  m_mpz_manager.to_string(result);
                                    if (m_manager.is_bool(fd->get_range())) tout << " [Boolean]";
                                    else tout << " [vector size: " << m_bv_util.get_bv_size(fd->get_range()) << "]";
                                    tout << std::endl; );

                SASSERT(m_mpz_manager.is_nonneg(result));
            }
        };

        class score_tracker {    
            ast_manager         & m_manager;
            unsynch_mpz_manager & m_mpz_manager;
            bv_util             & m_bv_util;
            powers              & m_powers;
            random_gen            m_rng;
            unsigned              m_random_bits;
            unsigned              m_random_bits_cnt;        
            vector<ptr_vector<expr> > m_traversal_stack;        
            evaluator             m_sls_evaluator;
            mpz                   m_zero, m_one, m_two;

            model                 m_dummy_model;
            model_evaluator       m_evaluator;
            expr_ref_buffer       m_temp_exprs;

            struct value_score { 
                value_score() : m(0), value(unsynch_mpz_manager::mk_z(0)), score(0.0), distance(0) { };
                ~value_score() { if (m) m->del(value); }
                unsynch_mpz_manager * m;
                mpz value;
                double score;
                unsigned distance; // max distance from any root
                value_score & operator=(const value_score & other) {
                    SASSERT(m == 0 || m == other.m);
                    if (m) m->set(value, 0); else m = other.m;
                    m->set(value, other.value);
                    score = other.score;
                    distance = other.distance;
                    return *this;
                }
            };

            typedef obj_map<expr, value_score> scores_type;    
            typedef obj_map<expr, ptr_vector<expr> > uplinks_type;
            typedef obj_map<func_decl, expr* > entry_point_type;
            typedef obj_map<expr, ptr_vector<func_decl> > occ_type;
            scores_type           m_scores;
            uplinks_type          m_uplinks;
            entry_point_type      m_entry_points;
            ptr_vector<func_decl> m_constants;
            ptr_vector<func_decl> m_temp_constants;
            occ_type              m_constants_occ;

        public:
            score_tracker(ast_manager & m, bv_util & bvu, unsynch_mpz_manager & mm, powers & p) :
                m_manager(m),
                m_mpz_manager(mm),
                m_bv_util(bvu),
                m_powers(p),
                m_random_bits_cnt(0),
                m_sls_evaluator(m, m_bv_util, *this, m_mpz_manager, p),
                m_zero(m_mpz_manager.mk_z(0)),
                m_one(m_mpz_manager.mk_z(1)),
                m_two(m_mpz_manager.mk_z(2)),
                m_dummy_model(m),
                m_evaluator(m_dummy_model),
                m_temp_exprs(m) {
            }
            
            ~score_tracker() {
                m_mpz_manager.del(m_zero);
                m_mpz_manager.del(m_one);
                m_mpz_manager.del(m_two);            
            }

            void set_value(expr * n, const mpz & r) {
                SASSERT(m_scores.contains(n));
                m_mpz_manager.set(m_scores.find(n).value, r);
            }

            void set_value(func_decl * fd, const mpz & r) {
                SASSERT(m_entry_points.contains(fd));
                expr * ep = get_entry_point(fd);
                set_value(ep, r);
            }

            mpz & get_value(expr * n) {            
                SASSERT(m_scores.contains(n));
                return m_scores.find(n).value;
            }

            mpz & get_value(func_decl * fd) {
                SASSERT(m_entry_points.contains(fd));
                expr * ep = get_entry_point(fd);
                return get_value(ep);
            }        

            void set_score(expr * n, double score) {
                SASSERT(m_scores.contains(n));
                m_scores.find(n).score = score;
            }

            void set_score(func_decl * fd, double score) {            
                SASSERT(m_entry_points.contains(fd));
                expr * ep = get_entry_point(fd);
                set_score(ep, score);    
            }

            double & get_score(expr * n) {
                SASSERT(m_scores.contains(n));
                return m_scores.find(n).score;
            }

            double & get_score(func_decl * fd) {
                SASSERT(m_entry_points.contains(fd));
                expr * ep = get_entry_point(fd);
                return get_score(ep);
            }

            unsigned get_distance(expr * n) {
                SASSERT(m_scores.contains(n));
                return m_scores.find(n).distance;
            }

            void set_distance(expr * n, unsigned d) {
                SASSERT(m_scores.contains(n));
                m_scores.find(n).distance = d;
            }

            expr * get_entry_point(func_decl * fd) {
                SASSERT(m_entry_points.contains(fd));
                return m_entry_points.find(fd);
            }

            bool has_uplinks(expr * n) {
                return m_uplinks.contains(n);
            }

            ptr_vector<expr> & get_uplinks(expr * n) {
                SASSERT(m_uplinks.contains(n));
                return m_uplinks.find(n);
            }

            void initialize(app * n) {
                // Build score table
                if (!m_scores.contains(n)) {
                    value_score vs;
                    vs.m = & m_mpz_manager;
                    m_scores.insert(n, vs);
                }

                // Update uplinks
                unsigned na = n->get_num_args();
                for (unsigned i = 0; i < na; i++) {
                    expr * c = n->get_arg(i); 
                    uplinks_type::obj_map_entry * entry = m_uplinks.insert_if_not_there2(c, ptr_vector<expr>());
                    entry->get_data().m_value.push_back(n);
                }

                func_decl * d = n->get_decl();

                if (n->get_num_args() == 0) {
                    if (d->get_family_id() != null_family_id) {
                        // Interpreted constant
                        mpz t;
                        value2mpz(n, t);
                        set_value(n, t);
                        m_mpz_manager.del(t);
                    }
                    else {
                        // Uninterpreted constant
                        m_entry_points.insert_if_not_there(d, n);
                        m_constants.push_back(d);
                    }
                }            
            }

            struct init_proc {
                ast_manager   & m_manager;        
                score_tracker & m_tracker;

                init_proc(ast_manager & m, score_tracker & tracker):
                    m_manager(m),
                    m_tracker(tracker) {
                }
        
                void operator()(var * n) {}
        
                void operator()(quantifier * n) {}
        
                void operator()(app * n) {
                    m_tracker.initialize(n);
                }
            };

            struct find_func_decls_proc {
                ast_manager   & m_manager;        
                ptr_vector<func_decl> & m_occs;

                find_func_decls_proc (ast_manager & m, ptr_vector<func_decl> & occs):
                    m_manager(m),
                    m_occs(occs) {
                }
        
                void operator()(var * n) {}
        
                void operator()(quantifier * n) {}
        
                void operator()(app * n) {
                    if (n->get_num_args() != 0)
                        return;
                    func_decl * d = n->get_decl();
                    if (d->get_family_id() != null_family_id)
                        return;
                    m_occs.push_back(d);
                }
            };

            void calculate_expr_distances(goal_ref const & g) {
                // precondition: m_scores is set up.
                unsigned sz = g->size();
                ptr_vector<app> stack;
                for (unsigned i = 0; i < sz; i++)
                    stack.push_back(to_app(g->form(i)));
                while (!stack.empty()) {
                    app * cur = stack.back();
                    stack.pop_back();
                
                    unsigned d = get_distance(cur);

                    for (unsigned i = 0; i < cur->get_num_args(); i++) {
                        app * child = to_app(cur->get_arg(i));                    
                        unsigned d_child = get_distance(child);
                        if (d >= d_child) {
                            set_distance(child, d+1);
                            stack.push_back(child);
                        }
                    }
                }
            }

            void initialize(goal_ref const & g) {
                init_proc proc(m_manager, *this);
                expr_mark visited;
                unsigned sz = g->size();
                for (unsigned i = 0; i < sz; i++) {
                    expr * e = g->form(i);                
                    for_each_expr(proc, visited, e);
                }

                visited.reset();

                for (unsigned i = 0; i < sz; i++) {
                    expr * e = g->form(i);
                    ptr_vector<func_decl> t;
                    m_constants_occ.insert_if_not_there(e, t);
                    find_func_decls_proc ffd_proc(m_manager, m_constants_occ.find(e));
                    expr_fast_mark1 visited;
                    quick_for_each_expr(ffd_proc, visited, e);
                }

                calculate_expr_distances(g);

                TRACE("sls", tout << "Initial model:" << std::endl; show_model(tout); );
            }

            void show_model(std::ostream & out) {
                unsigned sz = get_num_constants();
                for (unsigned i = 0; i < sz; i++) {
                    func_decl * fd = get_constant(i);
                    out << fd->get_name() << " = " << m_mpz_manager.to_string(get_value(fd)) << std::endl;
                }
            }

            model_ref get_model() {
                model_ref res = alloc(model, m_manager);
                unsigned sz = get_num_constants();
                for (unsigned i = 0; i < sz; i++) {
                    func_decl * fd = get_constant(i);
                    res->register_decl(fd, mpz2value(fd->get_range(), get_value(fd)));
                }
                return res;
            }

            unsigned get_num_constants() {
                return m_constants.size();
            }

            ptr_vector<func_decl> & get_constants() {
                return m_constants;
            }

            func_decl * get_constant(unsigned i) {
                return m_constants[i];
            }

            void set_random_seed(unsigned s) {
                m_rng.set_seed(s);
            }

            mpz get_random_bv(sort * s) {
                SASSERT(m_bv_util.is_bv_sort(s));
                unsigned bv_size = m_bv_util.get_bv_size(s);
                mpz r; m_mpz_manager.set(r, 0);            

                mpz temp;
                do
                {                
                    m_mpz_manager.mul(r, m_two, temp);                
                    m_mpz_manager.add(temp, get_random_bool(), r);
                } while (--bv_size > 0);            
                m_mpz_manager.del(temp);

                return r;
            }

            mpz & get_random_bool() {
                if (m_random_bits_cnt == 0) {
                    m_random_bits = m_rng();
                    m_random_bits_cnt = 15; // random_gen produces 15 bits of randomness.
                }

                bool val = (m_random_bits & 0x01) != 0;
                m_random_bits = m_random_bits >> 1;
                m_random_bits_cnt--;

                return (val) ? m_one : m_zero;
            }

            unsigned get_random_uint(unsigned bits) {
                if (m_random_bits_cnt == 0) {
                    m_random_bits = m_rng();
                    m_random_bits_cnt = 15; // random_gen produces 15 bits of randomness.
                }

                unsigned val = 0;
                while (bits-- > 0) {
                    if ((m_random_bits & 0x01) != 0) val++;
                    val <<= 1;
                    m_random_bits >>= 1;
                    m_random_bits_cnt--;

                    if (m_random_bits_cnt == 0) {
                        m_random_bits = m_rng();
                        m_random_bits_cnt = 15; // random_gen produces 15 bits of randomness.
                    }
                }

                return val;
            }

            mpz get_random(sort * s) {
                if (m_bv_util.is_bv_sort(s))
                    return get_random_bv(s);
                else if (m_manager.is_bool(s))
                    return get_random_bool();
                else
                    NOT_IMPLEMENTED_YET(); // This only works for bit-vectors for now.
            }    

            void randomize() {
                TRACE("sls", tout << "Abandoned model:" << std::endl; show_model(tout); );

                for (entry_point_type::iterator it = m_entry_points.begin(); it != m_entry_points.end(); it++) {
                    func_decl * fd = it->m_key;
                    sort * s = fd->get_range();
                    mpz temp = get_random(s);
                    set_value(it->m_value, temp);
                    m_mpz_manager.del(temp);
                }

                TRACE("sls", tout << "Randomized model:" << std::endl; show_model(tout); );
            }

            void randomize_local(goal_ref const & g) {
                ptr_vector<func_decl> & unsat_constants = get_unsat_constants(g);
                bool did_something = false;
                for (unsigned i = 0; i < unsat_constants.size(); i++) {
                    func_decl * fd = unsat_constants[i];
                    mpz temp = get_random(fd->get_range());
                    if (m_mpz_manager.neq(temp, get_value(fd)))
                        did_something = true;
                    update(fd, temp);
                    m_mpz_manager.del(temp);
                }
                TRACE("sls", tout << "Randomization candidates: ";
                             for (unsigned i = 0; i < unsat_constants.size(); i++)
                                 tout << unsat_constants[i]->get_name() << ", ";
                             tout << std::endl;
                             tout << "Locally randomized model: " << std::endl; show_model(tout); );
            }            

    #define _SCORE_AND_MIN

            double score_bool(expr * n, bool negated = false) {
                TRACE("sls_score", tout << ((negated)?"NEG ":"") << "BOOL: " << mk_ismt2_pp(n, m_manager) << std::endl; );

                double res = 0.0;
            
                if (is_uninterp_const(n)) {
                    const mpz & r = get_value(n);
                    if (negated)
                        res = (m_mpz_manager.is_one(r)) ? 0.0 : 1.0;
                    else
                        res = (m_mpz_manager.is_one(r)) ? 1.0 : 0.0;
                }            
                else if (m_manager.is_and(n)) {
                    SASSERT(!negated);
                    app * a = to_app(n);
                    expr * const * args = a->get_args();
                    #ifdef _SCORE_AND_MIN
                    double min = 1.0;
                    for (unsigned i = 0; i < a->get_num_args(); i++) {
                        double cur = get_score(args[i]);
                        if (cur < min) min = cur;
                    }
                    res = min;
                    #else 
                    double sum = 0.0;
                    for (unsigned i = 0; i < a->get_num_args(); i++)
                        sum += get_score(args[i]);
                    res = sum / (double) a->get_num_args();
                    #endif
                }
                else if (m_manager.is_or(n)) {
                    SASSERT(!negated);
                    app * a = to_app(n);
                    expr * const * args = a->get_args();
                    double max = 0.0;
                    for (unsigned i = 0; i < a->get_num_args(); i++) {
                        double cur = get_score(args[i]);
                        if (cur > max) max = cur;
                    }
                    res = max;
                }
                else if (m_manager.is_ite(n)) {
                    SASSERT(!negated);
                    app * a = to_app(n);
                    SASSERT(a->get_num_args() == 3);
                    const mpz & cond = get_value(a->get_arg(0));
                    double s_t = get_score(a->get_arg(1));
                    double s_f = get_score(a->get_arg(2));
                    res = (m_mpz_manager.is_one(cond)) ? s_t : s_f;
                }
                else if (m_manager.is_eq(n) || m_manager.is_iff(n)) {                
                    app * a = to_app(n);
                    SASSERT(a->get_num_args() == 2);
                    expr * arg0 = a->get_arg(0);
                    expr * arg1 = a->get_arg(1);
                    const mpz & v0 = get_value(arg0);
                    const mpz & v1 = get_value(arg1);

                    if (negated) {                    
                        res = (m_mpz_manager.eq(v0, v1)) ? 0.0 : 1.0;
                        TRACE("sls_score", tout << "V0 = " << m_mpz_manager.to_string(v0) << " ; V1 = " << 
                                                m_mpz_manager.to_string(v1) << std::endl; );
                    }
                    else if (m_manager.is_bool(arg0)) {
                        res = m_mpz_manager.eq(v0, v1) ? 1.0 : 0.0;
                        TRACE("sls_score", tout << "V0 = " << m_mpz_manager.to_string(v0) << " ; V1 = " << 
                                                m_mpz_manager.to_string(v1) << std::endl; );
                    }
                    else if (m_bv_util.is_bv(arg0)) {
                        mpz diff, diff_m1;
                        m_mpz_manager.bitwise_xor(v0, v1, diff);
                        unsigned hamming_distance = 0;
                        unsigned bv_sz = m_bv_util.get_bv_size(arg0);
                        #if 1 // unweighted hamming distance
                        while (!m_mpz_manager.is_zero(diff)) {
                            //m_mpz_manager.set(diff_m1, diff);
                            //m_mpz_manager.dec(diff_m1);
                            //m_mpz_manager.bitwise_and(diff, diff_m1, diff);
                            //hamming_distance++;
                            if (!m_mpz_manager.is_even(diff)) {
                                hamming_distance++;
                            }
                            m_mpz_manager.machine_div(diff, m_two, diff);
                        }
                        res = 1.0 - (hamming_distance / (double) bv_sz);                    
                        #else                    
                        rational r(diff);
                        r /= m_powers(bv_sz);
                        double dbl = r.get_double();
                        res = (dbl < 0.0) ? 1.0 : (dbl > 1.0) ? 0.0 : 1.0 - dbl;
                        #endif
                        TRACE("sls_score", tout << "V0 = " << m_mpz_manager.to_string(v0) << " ; V1 = " << 
                                                m_mpz_manager.to_string(v1) << " ; HD = " << hamming_distance << 
                                                " ; SZ = " << bv_sz << std::endl; );                    
                        m_mpz_manager.del(diff);
                        m_mpz_manager.del(diff_m1);
                    }
                    else
                        NOT_IMPLEMENTED_YET();
                }            
                else if (m_bv_util.is_bv_ule(n)) { // x <= y
                    app * a = to_app(n);
                    SASSERT(a->get_num_args() == 2);
                    const mpz & x = get_value(a->get_arg(0));
                    const mpz & y = get_value(a->get_arg(1));
                    unsigned bv_sz = m_bv_util.get_bv_size(a->get_decl()->get_domain()[0]);

                    if (negated) {
                        if (m_mpz_manager.gt(x, y))
                            res = 1.0; 
                        else {
                            mpz diff;
                            m_mpz_manager.sub(y, x, diff);
                            m_mpz_manager.inc(diff);                            
                            rational n(diff);
                            n /= rational(m_powers(bv_sz));                            
                            double dbl = n.get_double();
                            // In extreme cases, n is 0.9999 but to_double returns something > 1.0
                            res = (dbl > 1.0) ? 0.0 : (dbl < 0.0) ? 1.0 : 1.0 - dbl;
                            m_mpz_manager.del(diff);
                        }
                    }
                    else {
                        if (m_mpz_manager.le(x, y))                        
                            res = 1.0; 
                        else {
                            mpz diff;
                            m_mpz_manager.sub(x, y, diff);
                            rational n(diff);
                            n /= rational(m_powers(bv_sz));
                            double dbl = n.get_double();
                            res = (dbl > 1.0) ? 1.0 : (dbl < 0.0) ? 0.0 : dbl;
                            m_mpz_manager.del(diff);
                        }
                    }
                    TRACE("sls_score", tout << "x = " << m_mpz_manager.to_string(x) << " ; y = " << 
                                            m_mpz_manager.to_string(y) << " ; SZ = " << bv_sz << std::endl; );
                }
                else if (m_bv_util.is_bv_sle(n)) { // x <= y
                    app * a = to_app(n);
                    SASSERT(a->get_num_args() == 2);
                    mpz x; m_mpz_manager.set(x, get_value(a->get_arg(0)));
                    mpz y; m_mpz_manager.set(y, get_value(a->get_arg(1)));
                    unsigned bv_sz = m_bv_util.get_bv_size(a->get_decl()->get_domain()[0]);
                    const mpz & p = m_powers(bv_sz);
                    const mpz & p_half = m_powers(bv_sz-1);
                    if (x >= p_half) { m_mpz_manager.sub(x, p, x); } 
                    if (y >= p_half) { m_mpz_manager.sub(y, p, y); }                 

                    if (negated) {
                        if (x > y)
                            res = 1.0;
                        else {
                            mpz diff;
                            m_mpz_manager.sub(y, x, diff);
                            m_mpz_manager.inc(diff);
                            rational n(diff);
                            n /= p;
                            double dbl = n.get_double();
                            res = (dbl > 1.0) ? 0.0 : (dbl < 0.0) ? 1.0 : 1.0 - dbl;
                            m_mpz_manager.del(diff);
                        }
                        TRACE("sls_score", tout << "x = " << m_mpz_manager.to_string(x) << " ; y = " << 
                                                m_mpz_manager.to_string(y) << " ; SZ = " << bv_sz << std::endl; );
                    }
                    else {
                        if (x <= y)
                            res = 1.0;
                        else {
                            mpz diff;
                            m_mpz_manager.sub(x, y, diff);
                            rational n(diff);
                            n /= p;
                            double dbl = n.get_double();
                            res = (dbl > 1.0) ? 1.0 : (dbl < 0.0) ? 0.0 : dbl;
                            m_mpz_manager.del(diff);
                        }
                        TRACE("sls_score", tout << "x = " << m_mpz_manager.to_string(x) << " ; y = " << 
                                                m_mpz_manager.to_string(y) << " ; SZ = " << bv_sz << std::endl; );
                    }
                    m_mpz_manager.del(x);
                    m_mpz_manager.del(y);                
                }
                else if (m_manager.is_not(n)) {                
                    SASSERT(!negated);
                    app * a = to_app(n);
                    SASSERT(a->get_num_args() == 1);
                    expr * child = a->get_arg(0);
                    if (m_manager.is_and(child) || m_manager.is_or(child)) // Precondition: Assertion set is in NNF.
                        NOT_IMPLEMENTED_YET();
                    res = score_bool(child, true);
                }
                else if (m_manager.is_distinct(n)) {
                    app * a = to_app(n);
                    unsigned pairs = 0, distinct_pairs = 0;
                    unsigned sz = a->get_num_args();
                    for (unsigned i = 0; i < sz; i++) {
                        for (unsigned j = i+1; j < sz; j++) {
                            // pair i/j
                            const mpz & v0 = get_value(a->get_arg(0));
                            const mpz & v1 = get_value(a->get_arg(1));
                            pairs++;
                            if (v0 != v1)
                                distinct_pairs++;
                        }
                    }                
                    res = (distinct_pairs/(double)pairs);
                    if (negated) res = 1.0 - res;
                }
                else
                    NOT_IMPLEMENTED_YET();

                SASSERT(res >= 0.0 && res <= 1.0);

                TRACE("sls_score", tout << "SCORE = " << res << std::endl; );
                return res;
            }

            double score_bv(expr * n) {
                return 0.0; // a bv-expr is always scored as 0.0; we won't use those scores.
            }

            void value2mpz(expr * n, mpz & result) {
                m_mpz_manager.set(result, m_zero);

                if (m_manager.is_bool(n)) {
                    m_mpz_manager.set(result, m_manager.is_true(n) ? m_one : m_zero);
                }
                else if (m_bv_util.is_bv(n)) {
                    unsigned bv_sz = m_bv_util.get_bv_size(n);
                    rational q;
                    if (!m_bv_util.is_numeral(n, q, bv_sz))
                        NOT_IMPLEMENTED_YET();
                    mpq temp = q.to_mpq();
                    SASSERT(m_mpz_manager.is_one(temp.denominator()));
                    m_mpz_manager.set(result, temp.numerator());
                }
                else
                    NOT_IMPLEMENTED_YET();            
            }

            expr_ref mpz2value(sort * s, const mpz & r) {
                expr_ref res(m_manager);
                if (m_manager.is_bool(s))
                    res = (m_mpz_manager.is_zero(r)) ? m_manager.mk_false() : m_manager.mk_true();
                else if (m_bv_util.is_bv_sort(s)) {
                    rational rat(r);
                    res = m_bv_util.mk_numeral(rat, s);
                }
                else
                    NOT_IMPLEMENTED_YET();
                return res;
            }

            void eval(expr * n, mpz & result) {
                switch(n->get_kind()) {
                case AST_APP: {
                    app * a = to_app(n);
                    unsigned n_args = a->get_num_args();

                    if (n_args == 0) {                    
                        m_mpz_manager.set(result, get_value(n));
                    }
                    else {
                        m_sls_evaluator(a, result);

                    //#define _EVAL_CHECKED
                    #ifdef _EVAL_CHECKED
                        m_temp_exprs.reset();
                        for (unsigned i = 0; i < n_args; i++) {
                            expr * arg = a->get_arg(i);
                            const mpz & v = get_value(arg);
                            m_temp_exprs.push_back(mpz2value(m_manager.get_sort(arg), v));
                        }
                        expr_ref q(m_manager), temp(m_manager);
                        q = m_manager.mk_app(fd, m_temp_exprs.size(), m_temp_exprs.c_ptr());                                
                        m_evaluator(q, temp);
                        mpz check_res;
                        value2mpz(temp, check_res);
                        if (!m_mpz_manager.eq(check_res, result))
                            TRACE("sls", tout << "EVAL BUG: IS " << m_mpz_manager.to_string(result) << 
                                                    " SHOULD BE " << m_mpz_manager.to_string(check_res) << std::endl; );
                        SASSERT(m_mpz_manager.eq(check_res, result));
                        m_mpz_manager.del(check_res);
                    #endif
                    }
                    break;
                }
                default: 
                    NOT_IMPLEMENTED_YET();
                }
                // TRACE("sls", tout << "EVAL: " << mk_ismt2_pp(n, m_manager) << " IS " << res << std::endl;); 
            }

            double score(expr * n) {
                if (m_manager.is_bool(n))
                    return score_bool(n);
                else if (m_bv_util.is_bv(n))
                    return score_bv(n);
                else
                    NOT_IMPLEMENTED_YET();
            }

            void run_update(unsigned cur_depth) {
                // precondition: m_traversal_stack contains the entry point(s)
                expr_fast_mark1 visited;
                mpz new_value;

                SASSERT(cur_depth < m_traversal_stack.size());
                while (cur_depth != static_cast<unsigned>(-1)) {
                    ptr_vector<expr> & cur_depth_exprs = m_traversal_stack[cur_depth];

                    for (unsigned i = 0; i < cur_depth_exprs.size(); i++) {
                        expr * cur = cur_depth_exprs[i];

                        eval(cur, new_value);
                        set_value(cur, new_value);
                        set_score(cur, score(cur));

                        if (has_uplinks(cur)) {
                            ptr_vector<expr> & ups = get_uplinks(cur);
                            for (unsigned j = 0; j < ups.size(); j++) {
                                expr * next = ups[j];
                                unsigned next_d = get_distance(next);
                                SASSERT(next_d < cur_depth);
                                if (!visited.is_marked(next)) {
                                    m_traversal_stack[next_d].push_back(next);
                                    visited.mark(next);
                                }
                            }
                        }
                    }

                    cur_depth_exprs.reset();
                    cur_depth--;
                }

                m_mpz_manager.del(new_value);
            }
        
            void update_all() {
                unsigned max_depth = 0;

                for (entry_point_type::iterator it = m_entry_points.begin(); 
                        it != m_entry_points.end(); 
                        it++) {
                    expr * ep = get_entry_point(it->m_key);
                    unsigned cur_depth = get_distance(ep);
                    if (m_traversal_stack.size() <= cur_depth) 
                        m_traversal_stack.resize(cur_depth+1);
                    m_traversal_stack[cur_depth].push_back(ep);
                    if (cur_depth > max_depth) max_depth = cur_depth;
                }

                run_update(max_depth);
            }

            void update(func_decl * fd, const mpz & new_value) {
                set_value(fd, new_value);
                expr * ep = get_entry_point(fd);
                unsigned cur_depth = get_distance(ep);
                if (m_traversal_stack.size() <= cur_depth) 
                    m_traversal_stack.resize(cur_depth+1);
                m_traversal_stack[cur_depth].push_back(ep);

                run_update(cur_depth);
            }

            ptr_vector<func_decl> & get_unsat_constants(goal_ref const & g) {
                unsigned sz = g->size();

                if (sz == 1) {
                    return get_constants();
                }
                else {
                    m_temp_constants.reset();
                    for (unsigned i = 0; i < sz; i++) {
                        expr * q = g->form(i);
                        if (m_mpz_manager.eq(get_value(q), m_one))
                            continue;
                        ptr_vector<func_decl> const & this_decls = m_constants_occ.find(q);
                        unsigned sz2 = this_decls.size();
                        for (unsigned j = 0; j < sz2; j++) {
                            func_decl * fd = this_decls[j];
                            if (!m_temp_constants.contains(fd))
                                m_temp_constants.push_back(fd);
                        }
                    }
                    return m_temp_constants;
                }
            }
        };

        ast_manager   & m_manager;
        stats         & m_stats;
        unsynch_mpz_manager m_mpz_manager;
        powers          m_powers;
        mpz             m_zero, m_one, m_two;            
        bool            m_produce_models;
        volatile bool   m_cancel;    
        bv_util         m_bv_util;
        score_tracker   m_tracker;

        unsigned        m_max_restarts;
        unsigned        m_plateau_limit;

        typedef enum { MV_FLIP = 0, MV_INC, MV_DEC, MV_INV } move_type;        

        imp(ast_manager & m, params_ref const & p, stats & s) : 
            m_manager(m),
            m_stats(s),
            m_powers(m_mpz_manager),
            m_zero(m_mpz_manager.mk_z(0)),
            m_one(m_mpz_manager.mk_z(1)),
            m_two(m_mpz_manager.mk_z(2)),
            m_bv_util(m),
            m_tracker(m, m_bv_util, m_mpz_manager, m_powers)
        {
            updt_params(p);
        }

        ~imp() {
            m_mpz_manager.del(m_zero);
            m_mpz_manager.del(m_one);
            m_mpz_manager.del(m_two);
        }        

        ast_manager & m() const { return m_manager; }

        void set_cancel(bool f) { m_cancel = f; }
        void cancel() { set_cancel(true); }
        void reset_cancel() { set_cancel(false); }

        static void collect_param_descrs(param_descrs & r) {
            insert_produce_models(r);
            r.insert(":sls-restarts", CPK_UINT, "(default: infty) # of SLS restarts.");
            r.insert(":random-seed", CPK_UINT, "(default: 0) random seed.");
            r.insert(":plateau-limit", CPK_UINT, "(default: 100) SLS plateau limit.");
        }

        void updt_params(params_ref const & p) {        
            m_produce_models = p.get_bool(":produce-models", false);        
            m_max_restarts = p.get_uint(":sls-restarts", -1);
            m_tracker.set_random_seed(p.get_uint(":random-seed", 0));
            m_plateau_limit = p.get_uint(":plateau-limit", 100);
        }

        void checkpoint() { 
            if (m_cancel)
                throw tactic_exception(TACTIC_CANCELED_MSG);
            cooperate("sls");
        }

        bool full_eval(goal_ref const & g, model & mdl) {
            bool res = true;

            unsigned sz = g->size();
            for (unsigned i = 0; i < sz && res; i++) {
                checkpoint();
                expr_ref o(m_manager);

                if (!mdl.eval(g->form(i), o, true))
                    exit(ERR_INTERNAL_FATAL);

                res = m_manager.is_true(o.get());
            }        

            TRACE("sls", tout << "Evaluation: " << res << std::endl;);

            return res;
        }

        double top_score(goal_ref const & g) {
            #if 0
            double min = m_tracker.get_score(g->form(0));
            unsigned sz = g->size();
            for (unsigned i = 1; i < sz; i++) {
                double q = m_tracker.get_score(g->form(i));
                if (q < min) min = q;
            }
            TRACE("sls_top", tout << "Score distribution:"; 
                                for (unsigned i = 0; i < sz; i++)
                                    tout << " " << m_tracker.get_score(g->form(i));
                                tout << " MIN: " << min << std::endl; );
            return min;
            #else
            double top_sum = 0.0;
            unsigned sz = g->size();
            for (unsigned i = 0; i < sz; i++) {
                top_sum += m_tracker.get_score(g->form(i));
            }
            TRACE("sls_top", tout << "Score distribution:"; 
                                    for (unsigned i = 0; i < sz; i++)
                                        tout << " " << m_tracker.get_score(g->form(i));
                                    tout << " AVG: " << top_sum / (double) sz << std::endl; );
            return top_sum / (double) sz;
            #endif
        }

        double rescore(goal_ref const & g) {
            m_tracker.update_all();
            m_stats.m_full_evals++;
            return top_score(g);
        }

        double incremental_score(goal_ref const & g, func_decl * fd, const mpz & new_value) {
            m_tracker.update(fd, new_value);
            m_stats.m_incr_evals++;
            return top_score(g);
        }

        bool what_if(goal_ref const & g, func_decl * fd, const unsigned & fd_inx, const mpz & temp, 
                        double & best_score, unsigned & best_const, mpz & best_value) {
        
            #ifdef _DEBUG
            mpz old_value;
            m_mpz_manager.set(old_value, m_tracker.get_value(fd));
            #endif

            double r = incremental_score(g, fd, temp);
        
            #ifdef _DEBUG
            TRACE("sls_whatif", tout << "WHAT IF " << fd->get_name() << " WERE " << m_mpz_manager.to_string(temp) << 
                                        " --> " << r << std::endl; );
        
            m_mpz_manager.del(old_value);
            #endif

            if (r >= best_score) {
                best_score = r;
                best_const = fd_inx;            
                m_mpz_manager.set(best_value, temp);
                return true;
            }

            return false;
        }

        void mk_inc(unsigned bv_sz, const mpz & old_value, mpz & incremented) {
            unsigned shift;        
            m_mpz_manager.add(old_value, m_one, incremented);
            if (m_mpz_manager.is_power_of_two(incremented, shift) && shift == bv_sz)
                m_mpz_manager.set(incremented, m_zero);
        }

        void mk_dec(unsigned bv_sz, const mpz & old_value, mpz & decremented) {
            if (m_mpz_manager.is_zero(old_value)) {
                m_mpz_manager.set(decremented, m_powers(bv_sz));
                m_mpz_manager.dec(decremented);
            }
            else
                m_mpz_manager.sub(old_value, m_one, decremented);
        }

        void mk_inv(unsigned bv_sz, const mpz & old_value, mpz & inverted) {
            m_mpz_manager.bitwise_not(bv_sz, old_value, inverted);
        }

        void mk_flip(sort * s, const mpz & old_value, unsigned bit, mpz & flipped) {
            m_mpz_manager.set(flipped, m_zero);

            if (m_bv_util.is_bv_sort(s)) {
                mpz mask;
                m_mpz_manager.set(mask, m_powers(bit));
                m_mpz_manager.bitwise_xor(old_value, mask, flipped);
                m_mpz_manager.del(mask);
            }
            else if (m_manager.is_bool(s))
                m_mpz_manager.set(flipped, (m_mpz_manager.is_zero(old_value)) ? m_one : m_zero);
            else
                NOT_IMPLEMENTED_YET();
        }

        void mk_random_move(goal_ref const & g) {
            unsigned rnd_mv = 0;
            if (m_mpz_manager.is_one(m_tracker.get_random_bool())) rnd_mv=2;
            if (m_mpz_manager.is_one(m_tracker.get_random_bool())) rnd_mv++;
            move_type mt = (move_type) rnd_mv;

            // inversion doesn't make sense, let's do a flip instead.
            if (mt == MV_INV) mt = MV_FLIP;

            ptr_vector<func_decl> & unsat_constants = m_tracker.get_unsat_constants(g);                
            unsigned ucc = unsat_constants.size(); 
            unsigned rc = (m_tracker.get_random_uint((ucc < 16) ? 4 : (ucc < 256) ? 8 : (ucc < 4096) ? 12 : (ucc < 65536) ? 16 : 32)) % ucc;
            func_decl * fd = unsat_constants[rc];
            mpz new_value;
            unsigned bit = 0;

            switch (mt)
            {
            case MV_FLIP: {
                unsigned bv_sz = m_bv_util.get_bv_size(fd->get_range());
                bit = (m_tracker.get_random_uint((bv_sz < 16) ? 4 : (bv_sz < 256) ? 8 : (bv_sz < 4096) ? 12 : (bv_sz < 65536) ? 16 : 32)) % bv_sz;
                mk_flip(fd->get_range(), m_tracker.get_value(fd), bit, new_value);
                break;
            }
            case MV_INC: 
                mk_inc(m_bv_util.get_bv_size(fd->get_range()), m_tracker.get_value(fd), new_value);
                break;
            case MV_DEC: 
                mk_dec(m_bv_util.get_bv_size(fd->get_range()), m_tracker.get_value(fd), new_value);
                break;
            case MV_INV:
                mk_inv(m_bv_util.get_bv_size(fd->get_range()), m_tracker.get_value(fd), new_value);
                break;
            default:
                NOT_IMPLEMENTED_YET();
            }

            m_tracker.update(fd, new_value);            

            TRACE("sls", tout << "Randomization candidates: ";
                         for (unsigned i = 0; i < unsat_constants.size(); i++)
                             tout << unsat_constants[i]->get_name() << ", ";
                         tout << std::endl;
                         tout << "Random move: ";
                         switch (mt) {
                         case MV_FLIP: tout << "Flip #" << bit << " in " << fd->get_name() << std::endl; break;
                         case MV_INC: tout << "+1 for " << fd->get_name() << std::endl; break;
                         case MV_DEC: tout << "-1 for " << fd->get_name() << std::endl; break;
                         case MV_INV: tout << "NEG for " << fd->get_name() << std::endl; break;
                         }
                         tout << "Locally randomized model: " << std::endl; m_tracker.show_model(tout); );            

            m_mpz_manager.del(new_value);
        }

        double find_best_move(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score, 
                              unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move) {
            mpz old_value, temp;
            unsigned bv_sz;
            double new_score = score;

            for (unsigned i = 0; i < to_evaluate.size() && new_score < 1.0 ; i++) {
                func_decl * fd = to_evaluate[i];
                sort * srt = fd->get_range();
                bv_sz = (m_manager.is_bool(srt)) ? 1 : m_bv_util.get_bv_size(srt);
                m_mpz_manager.set(old_value, m_tracker.get_value(fd));

                // first try to flip every bit
                for (unsigned j = 0; j < bv_sz && new_score < 1.0; j++) {
                    // What would happen if we flipped bit #i ?                
                    mk_flip(srt, old_value, j, temp);                

                    if (what_if(g, fd, i, temp, new_score, best_const, best_value)) {
                        new_bit = j;
                        move = MV_FLIP;
                    }
                }

                if (m_bv_util.is_bv_sort(srt) && bv_sz > 1) {
                    if (!m_mpz_manager.is_even(old_value)) { 
                        // for odd values, try +1
                        mk_inc(bv_sz, old_value, temp);
                        if (what_if(g, fd, i, temp, new_score, best_const, best_value))
                            move = MV_INC;
                    }
                    else { 
                        // for even values, try -1
                        mk_dec(bv_sz, old_value, temp);
                        if (what_if(g, fd, i, temp, new_score, best_const, best_value))
                            move = MV_DEC;
                    }

                    // try inverting
                    mk_inv(bv_sz, old_value, temp);
                    if (what_if(g, fd, i, temp, new_score, best_const, best_value))
                        move = MV_INV;
                }

                // reset to what it was before
                double check = incremental_score(g, fd, old_value);
                SASSERT(check == score);
            }

            m_mpz_manager.del(old_value);
            m_mpz_manager.del(temp);
            return new_score;
        }        

        lbool search(goal_ref const & g) {        
            lbool res = l_undef;
            double score = 0.0, old_score = 0.0;
            unsigned new_const = -1, new_bit = 0;        
            mpz new_value;
            move_type move;
            
            score = rescore(g);
            TRACE("sls", tout << "Starting search, initial score   = " << std::setprecision(32) << score << std::endl;
                         tout << "Score distribution:"; 
                         for (unsigned i = 0; i < g->size(); i++)
                             tout << " " << std::setprecision(3) << m_tracker.get_score(g->form(i));
                         tout << " TOP: " << score << std::endl; ); 
        
            unsigned plateau_cnt = 0;

            while (plateau_cnt < m_plateau_limit) {                

                do {
                    checkpoint();
            
                    old_score = score;
                    new_const = -1;
                        
                    ptr_vector<func_decl> & to_evaluate = m_tracker.get_unsat_constants(g);

                    TRACE("sls_constants", tout << "Evaluating these constants: " << std::endl;
                                            for (unsigned i = 0 ; i < to_evaluate.size(); i++)
                                                tout << to_evaluate[i]->get_name() << std::endl; );

                    score = find_best_move(g, to_evaluate, score, new_const, new_value, new_bit, move);

                    if (new_const == static_cast<unsigned>(-1)) {
                        TRACE("sls", tout << "Local maximum reached; unsatisfied constraints: " << std::endl; 
                                        for (unsigned i = 0; i < g->size(); i++) {
                                            if (!m_mpz_manager.is_one(m_tracker.get_value(g->form(i))))
                                                tout << mk_ismt2_pp(g->form(i), m_manager) << std::endl;
                                        });

                        TRACE("sls_max", m_tracker.show_model(tout);
                                        tout << "Scores: " << std::endl;
                                        for (unsigned i = 0; i < g->size(); i++)
                                            tout << mk_ismt2_pp(g->form(i), m_manager) << " ---> " << 
                                            m_tracker.get_score(g->form(i)) << std::endl; );
                        score = old_score;
                    }
                    else {
                        m_stats.m_moves++;
                        func_decl * fd = to_evaluate[new_const];

                        TRACE("sls", tout << "Setting " << fd->get_name() << " to " << m_mpz_manager.to_string(new_value) << " (Move: ";
                                        switch (move) {
                                        case MV_FLIP:  
                                            tout << "Flip";
                                            if (!m_manager.is_bool(fd->get_range())) tout << " #" << new_bit;
                                            break;
                                        case MV_INC: 
                                            tout << "+1";
                                            break;
                                        case MV_DEC: 
                                            tout << "-1";
                                            break;
                                        case MV_INV: 
                                            tout << "NEG";
                                            break;
                                        };                                        
                                        tout << ") ; new score = " << std::setprecision(32) << score << std::endl; );

                        switch (move) {
                        case MV_FLIP: m_stats.m_flips++; break;
                        case MV_INC: m_stats.m_incs++; break;
                        case MV_DEC: m_stats.m_decs++; break;
                        case MV_INV: m_stats.m_invs++; break;
                        }
                    
                        score = incremental_score(g, fd, new_value);    

                        TRACE("sls", tout << "Score distribution:"; 
                                        for (unsigned i = 0; i < g->size(); i++)
                                            tout << " " << std::setprecision(3) << m_tracker.get_score(g->form(i));
                                        tout << " TOP: " << score << std::endl; );                        
                    }

                    if (score >= 1.0) {
                        // score could theoretically be imprecise.
                        bool all_true = true;
                        for (unsigned i = 0; i < g->size() && all_true; i++)
                            if (!m_mpz_manager.is_one(m_tracker.get_value(g->form(i))))
                                all_true=false;
                        if (all_true) {
                            res = l_true; // sat
                            goto bailout;
                        } else
                            TRACE("sls", tout << "Imprecise 1.0 score" << std::endl;);
                    }
                }
                while (score > old_score && res == l_undef);                

                if (score != old_score)
                    plateau_cnt = 0;
                else {
                    plateau_cnt++;
                    if (plateau_cnt < m_plateau_limit) {
                        m_tracker.randomize_local(g);
                        //mk_random_move(g);
                        score = top_score(g);
                    }
                }
            }

            bailout:
            m_mpz_manager.del(new_value);

            return res;
        }    

        void operator()(goal_ref const & g, model_converter_ref & mc) {
            //#ifdef _DEBUG
            //ptr_vector<expr> es;
            //for (unsigned i = 0; i < g->size(); i++)
            //    es.push_back(g->form(i));
            //expr_ref a(m_manager);
            //a = m_manager.mk_and(g->size(), es.c_ptr());
            //std::ofstream dot_out("top.dot", std::ios::out);
            //expr2dot(dot_out, a, m_manager);
            //dot_out.close();
            //#endif

            if (g->inconsistent()) {
                mc = 0;
                return;
            }

            m_tracker.initialize(g);
            lbool res = l_undef;
        
            do {
                checkpoint();
                if ((m_stats.m_restarts % 100) == 0)                        
                    report_tactic_progress("Searching... restarts left:", m_max_restarts - m_stats.m_restarts);
                
                res = search(g);

                if (res == l_undef)
                    m_tracker.randomize();
            }
            while (res != l_true && m_stats.m_restarts++ < m_max_restarts);
        
            if (res == l_true) {                
                if (m_produce_models) {
                    model_ref mdl = m_tracker.get_model();
                    mc = model2model_converter(mdl.get());
                    TRACE("sls_model", mc->display(tout); );
                }
                g->reset();
            }
            else
                mc = 0;
        }
    };
    
    ast_manager    & m;
    params_ref       m_params;
    imp            * m_imp;
    stats            m_stats;

public:
    sls_tactic(ast_manager & _m, params_ref const & p):
        m(_m),
        m_params(p) {
        m_imp = alloc(imp, m, p, m_stats);
    }

    virtual tactic * translate(ast_manager & m) {
        return alloc(sls_tactic, m, m_params);
    }

    virtual ~sls_tactic() {
        dealloc(m_imp);
    }

    virtual void updt_params(params_ref const & p) {
        m_params = p;
        m_imp->updt_params(p);
    }

    virtual void collect_param_descrs(param_descrs & r) {
        imp::collect_param_descrs(r);
    }
    
    virtual void operator()(goal_ref const & g, 
                            goal_ref_buffer & result, 
                            model_converter_ref & mc, 
                            proof_converter_ref & pc,
                            expr_dependency_ref & core) {
        SASSERT(g->is_well_sorted());
        m_imp->m_produce_models = g->models_enabled();        
        mc = 0; pc = 0; core = 0; result.reset();
        
        TRACE("sls", g->display(tout););
        tactic_report report("sls", *g);
        
        m_imp->operator()(g, mc);

        g->inc_depth();
        result.push_back(g.get());
        TRACE("sls", g->display(tout););
        SASSERT(g->is_well_sorted());
    }

    virtual void cleanup() {        
        imp * d = m_imp;
        #pragma omp critical (tactic_cancel)
        {
            d = m_imp;
        }
        dealloc(d);
        d = alloc(imp, m, m_params, m_stats);
        #pragma omp critical (tactic_cancel) 
        {
            m_imp = d;
        }
    }
    
    virtual void collect_statistics(statistics & st) const {
        double seconds = m_stats.m_stopwatch.get_current_seconds();            
        st.update("sls restarts", m_stats.m_restarts);
        st.update("sls full evals", m_stats.m_full_evals);
        st.update("sls incr evals", m_stats.m_incr_evals);
        st.update("sls incr evals/sec", m_stats.m_incr_evals/ seconds);
        st.update("sls FLIP moves", m_stats.m_flips);    
        st.update("sls INC moves", m_stats.m_incs);
        st.update("sls DEC moves", m_stats.m_decs);
        st.update("sls INV moves", m_stats.m_invs);
        st.update("sls moves", m_stats.m_moves);
        st.update("sls moves/sec", m_stats.m_moves / seconds);
    }

    virtual void reset_statistics() {
        m_stats.reset();
    }

    virtual void set_cancel(bool f) {
        if (m_imp)
            m_imp->set_cancel(f);
    }
};

tactic * mk_sls_tactic(ast_manager & m, params_ref const & p) {
    return and_then(fail_if_not(mk_is_qfbv_probe()), // Currently only QF_BV is supported.
                    clean(alloc(sls_tactic, m, p)));
}


tactic * mk_preamble(ast_manager & m, params_ref const & p) {
    params_ref main_p;
    main_p.set_bool(":elim-and", true);
    // main_p.set_bool(":pull-cheap-ite", true);
    main_p.set_bool(":push-ite-bv", true);
    main_p.set_bool(":blast-distinct", true);
    // main_p.set_bool(":udiv2mul", true);
    main_p.set_bool(":hi-div0", true);

    params_ref simp2_p = p;
    simp2_p.set_bool(":som", true);
    simp2_p.set_bool(":pull-cheap-ite", true);
    simp2_p.set_bool(":push-ite-bv", false);
    simp2_p.set_bool(":local-ctx", true);
    simp2_p.set_uint(":local-ctx-limit", 10000000);

    params_ref hoist_p;
    hoist_p.set_bool(":hoist-mul", true);
    // hoist_p.set_bool(":hoist-cmul", true);
    hoist_p.set_bool(":som", false);

    params_ref gaussian_p;
    // conservative gaussian elimination. 
    gaussian_p.set_uint(":gaussian-max-occs", 2); 

    return and_then(and_then(mk_simplify_tactic(m),                             
                             mk_propagate_values_tactic(m),
                             using_params(mk_solve_eqs_tactic(m), gaussian_p),
                             mk_elim_uncnstr_tactic(m),
                             mk_bv_size_reduction_tactic(m),
                             using_params(mk_simplify_tactic(m), simp2_p)),
                        using_params(mk_simplify_tactic(m), hoist_p),
                        mk_max_bv_sharing_tactic(m),
                        mk_nnf_tactic(m, p));
}

tactic * mk_qfbv_sls_tactic(ast_manager & m, params_ref const & p) {
    params_ref sls_p(p);
    sls_p.set_uint(":sls-restarts", 10000);
    sls_p.set_uint(":plateau-limit", 100);

    tactic * t = and_then(mk_preamble(m, p),
                          using_params(mk_sls_tactic(m, p), sls_p));
    
    t->updt_params(p);
    return t;
}