diff --git a/.vscode/settings.json b/.vscode/settings.json
index 379d8e4..48cb31a 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,6 +1,8 @@
 {
     "files.associations": {
         "*.ejs": "html",
-        "iostream": "cpp"
+        "iostream": "cpp",
+        "*.tcc": "cpp",
+        "new": "cpp"
     }
 }
\ No newline at end of file
diff --git a/acec.cpp b/acec.cpp
index d45d392..f1248a8 100644
--- a/acec.cpp
+++ b/acec.cpp
@@ -4,86 +4,362 @@
 #include "circuit.hpp"
 #include "sweep.hpp"
 
-#include "libopenf4.h"
+//#include "libopenf4.h"
+#include "src/cadical.hpp"
+
+#include "polynomial.h"
 
 extern "C" {
     #include "aiger.h"
 }
 
-#define pvar(i) ((string((i) < 0 ? "N" : "") + "A" + std::to_string(abs(i))).c_str())
+Sweep *S;
 
 Sweep* sweep_init(int argv, char* args[]) {
     Sweep *S = new Sweep();
     S->aig = aiger_init();
+    S->solver = new CaDiCaL::Solver;
     S->det_v_sz = 0;
     S->file = fopen(args[1], "r");
+    // S->rounds = atoi(args[2]);
+    // if (argv > 3) {
+    //     S->det_v = new int[argv -3];
+    //     for (int i = 3; i < argv; i++)
+    //         S->det_v[S->det_v_sz++] = atoi(args[i]);
+    // }
     return S;
 }
 
+Var* pvar(int id) {
+    static std::map<int, Var*> mp;
+    if(mp.count(id)) return mp[id];
+
+    std::string name = "A" + std::to_string(abs(id));
+    if(id < 0) name = "N" + name;
+
+    Var* var = new Var(name.c_str(), id > 0 ? S->topo_index[id] : (100000 + id) );
+
+    return mp[id] = var;
+}
+
+bool subsitute(Polynomial* &a, Polynomial* b) {
+    
+
+    Polynomial* result = divide_by_term(a, b->get_lt());
+
+    auto ltm = new Monomial(minus_one, b->get_lt());
+    push_mstack(ltm);
+    auto ltp = build_poly();
+
+    Polynomial* to_minus = multiply_poly(result, ltp);
+    
+
+    Polynomial* new_result = add_poly(a, to_minus);
+    
+
+    for(int i=1; i<b->size(); i++) {
+        push_mstack_end(b->get_mon(i));
+    }
+    Polynomial* tail = build_poly();
+    
+    Polynomial* new_tail = multiply_poly(result, tail);
+    
+
+    mpz_t c; mpz_init(c);
+    mpz_mul(c, b->get_mon(0)->coeff, minus_one);
+    Polynomial* tail_with_c = multiply_poly_with_constant(new_tail, c);
+    
+
+    Polynomial* done = add_poly(tail_with_c, new_result);
+
+    // printf("=======subsitute======\n");
+    // printf("a: "); a->print(stdout);
+    // printf("b: "); b->print(stdout);
+    // printf("result: "); result->print(stdout);
+    // printf("to_minus: "); to_minus->print(stdout);
+    // printf("new_result: "); new_result->print(stdout);
+    // printf("tail: "); tail->print(stdout);
+    // printf("new_tail: "); new_tail->print(stdout);
+    // printf("tail_with_c: "); tail_with_c->print(stdout);
+    // printf("done: "); done->print(stdout);
+
+    a = done;
+    return result->is_constant_zero_poly();
+}
+
+void getPolyOfGate(Sweep* s, int gateid, Polynomial* &resultA, Polynomial* &resultB) {
+    circuit *c = &(s->C[abs(gateid)]);
+    gateid = abs(gateid) * (c->neg ? -1 : 1);
+    if(c->type == And) {
+        add_to_vstack(pvar(gateid));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        for(int i=0; i<c->sz; i++) {
+            add_to_vstack(pvar(c->to[i]));
+        }
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        resultA = build_poly();
+    } else if(c->type == Xor) {
+        add_to_vstack(pvar(gateid));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(minus_two, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        resultA = build_poly();
+    } else if(c->type == HA) {
+        add_to_vstack(pvar(gateid));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(minus_two, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        resultA = build_poly();
+
+        add_to_vstack(pvar(c->carrier));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        for(int i=0; i<c->sz; i++) {
+            add_to_vstack(pvar(c->to[i]));
+        }
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        resultB = build_poly();
+    } else if(c->type == FA) {
+        add_to_vstack(pvar(gateid));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(minus_two, build_term_from_stack()));
+
+        add_to_vstack(pvar(c->to[1]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(minus_two, build_term_from_stack()));
+
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(minus_two, build_term_from_stack()));
+
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(four, build_term_from_stack()));
+        
+        resultA = build_poly();
+
+        add_to_vstack(pvar(c->carrier));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[1]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(minus_two, build_term_from_stack()));
+        
+        resultB = build_poly();
+    } else if(c->type == Majority) {
+        add_to_vstack(pvar(gateid));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[1]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(c->to[0]));
+        add_to_vstack(pvar(c->to[1]));
+        add_to_vstack(pvar(c->to[2]));
+        push_mstack(new Monomial(minus_two, build_term_from_stack()));
+        resultA = build_poly();
+    }
+}
+
+bool poly_cmp(Polynomial *a, Polynomial *b) {
+    return a->get_lt()->get_var()->get_level() > b->get_lt()->get_var()->get_level();
+}
+
+std::map<Polynomial*, Polynomial*> another;
 int main(int argv, char* args[]) {
-    Sweep *S = sweep_init(argv, args);
+
+    init_mpz(19260817);
+
+    S = sweep_init(argv, args);
+
     S->solve();
 
-    using namespace std;
-    //using namespace F4;
-    
-    // Create polynomial array.
-    vector<string> polynomialArray;
-    
-    // Create variable name array.
-    vector<string> variableName;
+    std::map<std::string, Polynomial*> nas;
+    for(int i=1; i<=S->maxvar; i++) {
+        add_to_vstack(pvar(i));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        add_to_vstack(pvar(-i));
+        push_mstack(new Monomial(one, build_term_from_stack()));
+        push_mstack(new Monomial(minus_one, build_term_from_stack()));
+        Polynomial *poly = build_poly();
+        nas[pvar(-i)->get_name()] = poly;
+        nas[pvar(i)->get_name()] = poly;
+    }
 
-    set<string> vars;
+    std::vector<Polynomial*> polys;
 
-    int t = S->maxvar;
+    std::set<int> reserved_vars;
+    std::vector<Polynomial*> subsitute_vars;
+    for (int i = 1; i <= S->maxvar; i++) {
+        circuit *c = &(S->C[i]);
+        if (!c->sz || S->del[i] == 2) continue;
+        if(c->type == Xor) {
+            reserved_vars.insert(i);
+            // for(int j=0; j<c->sz; j++)
+            //     reserved_vars.insert(abs(c->to[j]));
+        }
+    }
+    for (int i = 1; i <= S->maxvar; i++) {
+        circuit *c = &(S->C[i]);
+        if (!c->sz || S->del[i] == 2) continue;
+        if(!reserved_vars.count(i)) {
+            Polynomial *p, *q;
+            getPolyOfGate(S, i, p, q);
+            while(p->get_lt()->get_var_name()[0] == 'N') {
+                Polynomial *to_div = nas[p->get_lt()->get_var_name()];
+                subsitute(p, to_div);
+            }
+            subsitute_vars.push_back(p);
+        }
+    }
+
+    printf("reserved: %d ; subsitute: %d\n", reserved_vars.size(), subsitute_vars.size());
+
+    for (int i = 1; i <= S->maxvar; i++) {
+        circuit *c = &(S->C[i]);
+        if (!c->sz || S->del[i] == 2) continue;
+    }
 
     for (int i = 1; i <= S->maxvar; i++) {
         circuit *c = &(S->C[i]);
         if (!c->sz || S->del[i] == 2) continue;
 
-        if(c->type == And) {
-            char term[1024];
-            sprintf(term, "-%s+%s", pvar(i * (S->C[i].neg ? -1 : 1)), pvar(c->to[0]));
-            for(int i=1; i<c->sz; i++) {
-                sprintf(term, "%s*%s", term, pvar(c->to[i]));
-            }
-            polynomialArray.push_back(term);
-            printf("%s\n", term);
-        }
-        if(c->type == Xor) {
-            string last = pvar(c->to[0]);
-            char term[1024];
-            for(int i=1; i<c->sz-1; i++) {
-                string tmp = pvar(++t);
-                sprintf(term, "-%s-2*%s*%s+%s+%s", tmp.c_str(), last.c_str(), pvar(c->to[i]), last.c_str(), pvar(c->to[i]));
-                polynomialArray.push_back(term);
-                printf("%s\n", term);
-                last = tmp;
-            }
-            sprintf(term, "-%s-2*%s*%s+%s+%s", pvar(i * (S->C[i].neg ? -1 : 1)), last.c_str(), pvar(c->to[c->sz-1]), last.c_str(), pvar(c->to[c->sz-1]));
-            polynomialArray.push_back(term);
-            printf("%s\n", term);
+        if(!reserved_vars.count(i)) continue;
+
+        //if(c->sz == 2 && abs(c->to[0]) <= 14 && abs(c->to[1]) <= 14) continue;
+
+        Polynomial *resultA, *resultB = nullptr;
+        getPolyOfGate(S, i, resultA, resultB);
+
+        printf("  original:\t"); resultA->print(stdout);
+
+        while(resultA->get_lt()->get_var_name()[0] == 'N') {
+            Polynomial *to_div = nas[resultA->get_lt()->get_var_name()];
+            subsitute(resultA, to_div);
         }
 
+        printf("  pos-var:\t"); resultA->print(stdout);
+
+        for(auto subs : subsitute_vars) {
+            //printf("delete: "); subs->print(stdout);
+            subsitute(resultA, subs);
+        }
+
+        printf("  xor-relative:\t"); resultA->print(stdout);
+
+        polys.push_back(resultA);
+        
         if (c->type == HA || c->type == FA) {
-            char term[1024];
-            sprintf(term, "-%s-2*%s+%s", pvar(i * (S->C[i].neg ? -1 : 1)), pvar(c->carrier), pvar(c->to[0]));
-            for(int i=1; i<c->sz; i++) {
-                sprintf(term, "%s+%s", term, pvar(c->to[i]));
-            }
-            polynomialArray.push_back(term);
-            printf("%s\n", term);
+            printf("( %d %d )", i * (S->C[i].neg ? -1 : 1), c->carrier); 
+        }
+        else {
+            printf("%d", i * (S->C[i].neg ? -1 : 1));
         }
 
-        if(c->type == Majority) {
-            char term[1024];
-            sprintf(term, "-%s-2*%s+%s", pvar(++t), pvar(i * (S->C[i].neg ? -1 : 1)), pvar(c->to[0]));
-            for(int i=1; i<c->sz; i++) {
-                sprintf(term, "%s+%s", term, pvar(c->to[i]));
-            }
-            polynomialArray.push_back(term);
-            printf("%s\n", term);
+        printf(" = %s ( ", gate_type[c->type].c_str());
+
+        for (int j = 0; j < c->sz; j++) {
+            printf("%d ", c->to[j]);
         }
+        puts(")");
+    }
+
+    add_to_vstack(pvar(32));
+    push_mstack(new Monomial(one, build_term_from_stack()));
+
+    Polynomial *result = build_poly();
+
+    std::sort(polys.begin(), polys.end(), poly_cmp);
+
+    for(auto p : polys) {
+        printf("now: "); result->print(stdout);
+        printf("div: "); p->print(stdout);
+        subsitute(result, p);
+    }
+    
+    return 0;
+}
+
+// for (int i = 1; i <= S->maxvar; i++) {
+    //     circuit *c = &(S->C[i]);
+    //     if (!c->sz || S->del[i] == 2) continue;
+
+    //     if(c->type == And) {
+    //         char term[1024];
+    //         sprintf(term, "-%s+%s", pvar(i * (S->C[i].neg ? -1 : 1)), pvar(c->to[0]));
+    //         for(int i=1; i<c->sz; i++) {
+    //             sprintf(term, "%s*%s", term, pvar(c->to[i]));
+    //         }
+    //         polynomialArray.push_back(term);
+    //         printf("%s\n", term);
+    //     }
+    //     if(c->type == Xor) {
+    //         string last = pvar(c->to[0]);
+    //         char term[1024];
+    //         for(int i=1; i<c->sz-1; i++) {
+    //             string tmp = pvar(++t);
+    //             sprintf(term, "-%s-2*%s*%s+%s+%s", tmp.c_str(), last.c_str(), pvar(c->to[i]), last.c_str(), pvar(c->to[i]));
+    //             polynomialArray.push_back(term);
+    //             printf("%s\n", term);
+    //             last = tmp;
+    //         }
+    //         sprintf(term, "-%s-2*%s*%s+%s+%s", pvar(i * (S->C[i].neg ? -1 : 1)), last.c_str(), pvar(c->to[c->sz-1]), last.c_str(), pvar(c->to[c->sz-1]));
+    //         polynomialArray.push_back(term);
+    //         printf("%s\n", term);
+    //     }
+
+    //     if (c->type == HA || c->type == FA) {
+    //         char term[1024];
+    //         sprintf(term, "-%s-2*%s+%s", pvar(i * (S->C[i].neg ? -1 : 1)), pvar(c->carrier), pvar(c->to[0]));
+    //         for(int i=1; i<c->sz; i++) {
+    //             sprintf(term, "%s+%s", term, pvar(c->to[i]));
+    //         }
+    //         polynomialArray.push_back(term);
+    //         printf("%s\n", term);
+    //     }
+
+    //     if(c->type == Majority) {
+    //         char term[1024];
+    //         sprintf(term, "-%s-2*%s+%s", pvar(++t), pvar(i * (S->C[i].neg ? -1 : 1)), pvar(c->to[0]));
+    //         for(int i=1; i<c->sz; i++) {
+    //             sprintf(term, "%s+%s", term, pvar(c->to[i]));
+    //         }
+    //         polynomialArray.push_back(term);
+    //         printf("%s\n", term);
+    //     }
         
         // if (c->type == HA || c->type == FA) {
         //     printf("( %d %d )", i * (S->C[i].neg ? -1 : 1), c->carrier); 
@@ -98,24 +374,24 @@ int main(int argv, char* args[]) {
         //     printf("%d ", c->to[j]);
         // }
         // puts(")");
-    }
+    // }
 
-    for(int i=t; i>=1; i--) {
-        variableName.push_back(pvar(i));
-        variableName.push_back(pvar(-i));
-        char term[1024];
-        sprintf(term, "-%s+%s^2", pvar(i), pvar(i));
-        polynomialArray.emplace_back(term);
-        printf("%s\n", term);
-        sprintf(term, "%s+%s", pvar(i), pvar(-i));
-        polynomialArray.emplace_back(term);
-        printf("%s\n", term);
-    }
+    // for(int i=t; i>=1; i--) {
+    //     variableName.push_back(pvar(i));
+    //     variableName.push_back(pvar(-i));
+    //     char term[1024];
+    //     sprintf(term, "-%s+%s^2", pvar(i), pvar(i));
+    //     polynomialArray.emplace_back(term);
+    //     printf("%s\n", term);
+    //     sprintf(term, "%s+%s", pvar(i), pvar(-i));
+    //     polynomialArray.emplace_back(term);
+    //     printf("%s\n", term);
+    // }
 
-    char term[1024];
-    sprintf(term, "-%s+1", pvar(S->maxvar));
-    polynomialArray.emplace_back(term);
-    printf("%s\n", term);
+    // char term[1024];
+    // sprintf(term, "-%s+1", pvar(S->maxvar));
+    // polynomialArray.emplace_back(term);
+    // printf("%s\n", term);
 
     // for(int i = 0; i < 6; i++)
     // {
@@ -131,17 +407,72 @@ int main(int argv, char* args[]) {
     // polynomialArray.emplace_back("x0*x1*x2*x3*x4*x5-1");
     
     // Compute a reduce groebner basis.
-    vector<string> basis = groebnerBasisF4(7, variableName.size(), variableName, polynomialArray, 1, 0);
+    //vector<string> basis = groebnerBasisF4(7, variableName.size(), variableName, polynomialArray, 1, 0);
     
-    for(size_t i = 0; i < basis.size(); i++)
-    {
-        cout << basis[i] << endl;
-    }
+    // for(size_t i = 0; i < basis.size(); i++)
+    // {
+    //     cout << basis[i] << endl;
+    // }
 
-    for(int i=t; i>=1; i--) {
-        printf("(declare-fun %s () Bool)", pvar(i));
-        printf("(declare-fun %s () Bool)", pvar(-i));
-    }
-    
-    return 0;
-}
\ No newline at end of file
+// for(int i=1; i<=t; i++) {
+    //     printf("(declare-fun %s () Bool)\n", pvar(i).c_str());
+    // }
+
+    // for (int i = 1; i <= S->maxvar; i++) {
+    //     circuit *c = &(S->C[i]);
+    //     if (!c->sz || S->del[i] == 2) continue;
+    //     int var = i * (S->C[i].neg ? -1 : 1);
+
+    //     if(c->type == And) {
+    //         string clause = "(assert (= " + pvar(var) + " (and";
+    //         for(int i=0; i<c->sz; i++) {
+    //             clause +=  " " + pvar(c->to[i]);
+    //         }
+    //         clause += ")))";
+    //         cout << clause << endl;
+    //     }
+    //     if(c->type == Xor) {
+    //         string clause = "(assert (= " + pvar(var) + " (xor";
+    //         for(int i=0; i<c->sz; i++) {
+    //             clause +=  " " + pvar(c->to[i]);
+    //         }
+    //         clause += ")))";
+    //         cout << clause << endl;
+    //     }
+
+    //     if (c->type == HA || c->type == FA) {
+    //         string clause = "(assert (= (+ " + pvar(var) + " (* 2 "+pvar(c->carrier)+")) (+ ";
+    //         for(int i=0; i<c->sz; i++) {
+    //             clause +=  " " + pvar(c->to[i]);
+    //         }
+    //         clause += ")))";
+    //         cout << clause << endl;
+    //     }
+
+    //     if(c->type == Majority) {
+    //         string ta = pvar(c->to[0]);
+    //         string tb = pvar(c->to[1]);
+    //         string tc = pvar(c->to[2]);
+    //         string clause = "(assert (= "+pvar(var)+" (or (and "+ta+" "+tb+") (and "+ta+" "+tc+") (and "+tb+" "+tc+"))))";
+    //         cout << clause << endl;
+    //     }
+        
+    //     // if (c->type == HA || c->type == FA) {
+    //     //     printf("( %d %d )", i * (S->C[i].neg ? -1 : 1), c->carrier); 
+    //     // }
+    //     // else {
+    //     //     printf("%d", i * (S->C[i].neg ? -1 : 1));
+    //     // }
+
+    //     // printf(" = %s ( ", gate_type[c->type].c_str());
+
+    //     // for (int j = 0; j < c->sz; j++) {
+    //     //     printf("%d ", c->to[j]);
+    //     // }
+    //     // puts(")");
+    // }
+
+    // printf("(assert (= false %s))\n", pvar(S->maxvar).c_str());
+
+    // printf("(check-sat)\n");
+    //printf("(get-model)\n");
\ No newline at end of file
diff --git a/acec.log b/acec.log
new file mode 100644
index 0000000..e69de29
diff --git a/circuit.cpp b/circuit.cpp
index 7cb6c89..c50d477 100644
--- a/circuit.cpp
+++ b/circuit.cpp
@@ -46,8 +46,8 @@ bool Sweep::match_majority(int x) {
     if (C[-v].outs <= 1) del[-v] = 2;
     if (C[-w].outs <= 1) del[-w] = 2;
 
-    C[x][0] = a; C[x][1] = b;
-    C[x].push(C[-w][1]);
+    C[x][0] = -a; C[x][1] = -b;
+    C[x].push(-C[-w][1]);
     C[x].type = Majority;
     return true;
 }
@@ -163,7 +163,6 @@ void Sweep::match_FA() {
 
     for(int i=1; i<=maxvar; i++) {
         if (!C[i].sz || del[i] == 2) continue; 
-        //printf("X: %d\n", i);
 
         circuit *c = &C[i];
 
@@ -347,7 +346,7 @@ void Sweep::to_dot_graph(const char* filename, int end_point) {
             /**
              * 删除初始输入
             */
-            if(abs(c->to[j]) <= num_inputs) continue;
+            if(abs(c->to[j]) <= 14) continue;
 
             sprintf(str, "A%d->A%d[arrowhead=%s]\n", abs(c->to[j]), u, !line_positive(c->to[j]) ? "dot" : "none");
             file << str;
@@ -365,6 +364,7 @@ void Sweep::to_dot_graph(const char* filename, int end_point) {
 }
 
 void Sweep::identify() {
+    
     del = new int[maxvar + 1];
     for (int i = 1; i <= maxvar; i++) del[i] = 0;
     recalculate_outs();
@@ -373,21 +373,19 @@ void Sweep::identify() {
         if (match_xor(i)) continue;
     }
     
-    recalculate_outs();
+    // recalculate_outs();
 
-    for (int i = 1; i <= maxvar; i++) {
-        if (!C[i].sz || del[i] == 2) continue;
-        if (match_majority(i)) continue;
-    }
+    // for (int i = 1; i <= maxvar; i++) {
+    //     if (!C[i].sz || del[i] == 2) continue;
+    //     if (match_majority(i)) continue;
+    // }
 
     recalculate_outs();
-    
-    adjust_not();
-    match_HA();
+    //adjust_not();
+    //match_HA();
 
-    to_multi_input_gates();
-
-    match_FA();
+    //to_multi_input_gates();
+    //match_FA();
 
     // printf("digraph \"graph\" {\n");
     // for (int i = 1; i <= maxvar; i++) {
@@ -411,8 +409,35 @@ void Sweep::identify() {
     // }
     // printf("}\n");
 
-    //to_dot_graph("graph1.dot", abs(C[maxvar].to[0]));
-    //to_dot_graph("graph2.dot", abs(C[maxvar].to[1]));
+    recalculate_outs();
+    // for (int i = 1; i <= maxvar; i++) {
+    //     circuit *c = &C[i];
+    //     if (!c->sz || del[i] == 2) continue;
+        
+    //     if (c->type == HA || c->type == FA)
+    //         printf("( %d %d )", i * (C[i].neg ? -1 : 1), c->carrier); 
+    //     else
+    //         printf("%d", i * (C[i].neg ? -1 : 1));
+
+    //     printf(" = %s ( ", gate_type[c->type].c_str());
+
+    //     for (int j = 0; j < c->sz; j++) {
+    //         printf("%d ", c->to[j]);
+    //     }
+
+    //     puts(")");
+    // }
+
+    inv_C = new vec<int>[maxvar + 1];
+    for (int i = 1; i <= maxvar; i++) {
+        circuit *c = &C[i];
+        if (!c->sz || del[i] == 2) continue; 
+        for (int j = 0; j < c->sz; j++) {
+            inv_C[abs(c->to[j])].push(i);
+        }
+    }
+    // to_dot_graph("graph1.dot", 291);
+    // to_dot_graph("graph2.dot", 175);
 
     // recalculate_outs();
     // for (int i = 1; i <= maxvar; i++) {
@@ -420,7 +445,5 @@ void Sweep::identify() {
     //     if (del[i] == 2) continue; 
     //     printf("%d : %d (outs)\n", i, c->outs);
     // }
-
-
-
+    
 }
\ No newline at end of file
diff --git a/cms.log b/cms.log
new file mode 100644
index 0000000..8ae66aa
--- /dev/null
+++ b/cms.log
@@ -0,0 +1,408 @@
+-293 -292 0
+-293 176 0
+292 -176 293 0
+-294 292 0
+-294 -176 0
+-292 176 294 0
+289 231 292  0
+-173 154 176  0
+-289 -288 0
+-289 287 0
+288 -287 289 0
+228 197 231  0
+-173 172 0
+-173 -157 0
+-172 157 173 0
+-151 124 154  0
+-288 -285 0
+-288 -242 0
+285 242 288 0
+-287 -286 0
+-287 -249 0
+286 249 287 0
+225 208 228  0
+-197 -196 0
+-197 195 0
+196 -195 197 0
+-172 171 0
+-172 -160 0
+-171 160 172 0
+-150 127 157  0
+-151 150 0
+-151 -127 0
+-150 127 151 0
+121 88 124  0
+-285 -284 0
+-285 283 0
+284 -283 285 0
+-242 -241 0
+-242 240 0
+241 -240 242 0
+-286 -285 0
+-286 -248 0
+285 248 286 0
+-249 -248 0
+-249 -242 0
+248 242 249 0
+222 216 225  0
+205 200 208  0
+-196 -193 0
+-196 -180 0
+193 180 196 0
+-195 -194 0
+-195 -187 0
+194 187 195 0
+-171 170 0
+-171 -163 0
+-170 163 171 0
+149 130 160  0
+-150 -149 0
+-150 -130 0
+149 130 150 0
+-119 116 127  0
+-121 -120 0
+-121 -115 0
+120 115 121 0
+85 78 88  0
+-284 -281 0
+-284 -255 0
+281 255 284 0
+-283 -282 0
+-283 -262 0
+282 262 283 0
+-241 -238 0
+-241 97 0
+238 -97 241 0
+-240 -239 0
+-240 -232 0
+239 232 240 0
+245 193 248  0
+-219 42 222  0
+213 20 216  0
+-205 -204 0
+-205 203 0
+204 -203 205 0
+-41 27 200  0
+190 31 193  0
+-180 179 0
+-180 -116 0
+-179 116 180 0
+-194 -193 0
+-194 -186 0
+193 186 194 0
+-187 -186 0
+-187 -180 0
+186 180 187 0
+-170 169 0
+-170 -166 0
+-169 166 170 0
+-147 144 163  0
+-149 -148 0
+-149 -143 0
+148 143 149 0
+112 109 130  0
+114 91 119  0
+-116 106 0
+-116 105 0
+-106 -105 116 0
+-120 -119 0
+-120 116 0
+119 -116 120 0
+-115 -114 0
+-115 -91 0
+114 91 115 0
+-82 81 85  0
+75 48 78  0
+-281 -280 0
+-281 279 0
+280 -279 281 0
+-255 -254 0
+-255 253 0
+254 -253 255 0
+-282 -281 0
+-282 -261 0
+281 261 282 0
+-262 -261 0
+-262 -255 0
+261 255 262 0
+-235 105 238  0
+-97 96 0
+-97 95 0
+-96 -95 97 0
+-239 -238 0
+-239 -58 0
+238 58 239 0
+-232 97 0
+-232 -58 0
+-97 58 232 0
+186 180 245  0
+82 21 219  0
+-42 5 0
+-42 4 0
+-5 -4 42 0
+-213 -212 0
+-213 211 0
+212 -211 213 0
+17 16 20  0
+-204 63 0
+-204 -31 0
+-63 31 204 0
+-203 -202 0
+-203 -201 0
+202 201 203 0
+38 37 41  0
+-27 26 0
+-27 25 0
+-26 -25 27 0
+63 54 190  0
+26 25 31  0
+-179 -178 0
+-179 -177 0
+178 177 179 0
+-183 62 186  0
+-169 168 0
+-169 167 0
+-168 -167 169 0
+-140 137 166  0
+142 133 147  0
+-144 12 0
+-144 6 0
+-12 -6 144 0
+-148 -147 0
+-148 144 0
+147 -144 148 0
+-143 -142 0
+-143 -133 0
+142 133 143 0
+103 94 112  0
+106 105 109  0
+-114 -113 0
+-114 -104 0
+113 104 114 0
+73 70 91  0
+-106 12 0
+-106 2 0
+-12 -2 106 0
+-105 6 0
+-105 5 0
+-6 -5 105 0
+-82 12 0
+-82 9 0
+-12 -9 82 0
+-81 -80 0
+-81 -79 0
+80 79 81 0
+-75 -74 0
+-75 -61 0
+74 61 75 0
+45 36 48  0
+-280 -277 0
+-280 -101 0
+277 101 280 0
+-279 -278 0
+-279 -269 0
+278 269 279 0
+-254 251 0
+-254 144 0
+-251 -144 254 0
+-253 -252 0
+-253 -250 0
+252 250 253 0
+258 238 261  0
+106 55 235  0
+-96 15 0
+-96 8 0
+-15 -8 96 0
+-95 13 0
+-95 3 0
+-13 -3 95 0
+53 52 58  0
+-21 11 0
+-21 7 0
+-11 -7 21 0
+-212 67 0
+-212 62 0
+-67 -62 212 0
+-211 -210 0
+-211 -209 0
+210 209 211 0
+-17 10 0
+-17 8 0
+-10 -8 17 0
+-16 14 0
+-16 13 0
+-14 -13 16 0
+-63 5 0
+-63 2 0
+-5 -2 63 0
+-202 54 0
+-202 -31 0
+-54 31 202 0
+-201 63 0
+-201 54 0
+-63 -54 201 0
+-38 15 0
+-38 2 0
+-15 -2 38 0
+-37 6 0
+-37 3 0
+-6 -3 37 0
+-26 8 0
+-26 7 0
+-8 -7 26 0
+-25 13 0
+-25 10 0
+-13 -10 25 0
+-54 53 0
+-54 52 0
+-53 -52 54 0
+-178 105 0
+-178 55 0
+-105 -55 178 0
+-177 106 0
+-177 55 0
+-106 -55 177 0
+67 28 183  0
+-62 15 0
+-62 6 0
+-15 -6 62 0
+-168 12 0
+-168 8 0
+-12 -8 168 0
+-167 13 0
+-167 5 0
+-13 -5 167 0
+135 134 140  0
+-137 12 0
+-137 11 0
+-12 -11 137 0
+-142 -141 0
+-142 -136 0
+141 136 142 0
+-101 98 133  0
+-103 -102 0
+-103 -97 0
+102 97 103 0
+-58 55 94  0
+-113 -112 0
+-113 -109 0
+112 109 113 0
+-104 -103 0
+-104 -94 0
+103 94 104 0
+60 51 73  0
+-67 66 70  0
+-80 67 0
+-80 -66 0
+-67 66 80 0
+-79 63 0
+-79 62 0
+-63 -62 79 0
+-74 -73 0
+-74 -70 0
+73 70 74 0
+-61 -60 0
+-61 -51 0
+60 51 61 0
+-42 41 45  0
+33 24 36  0
+-277 -276 0
+-277 275 0
+276 -275 277 0
+96 95 101  0
+-278 -277 0
+-278 -268 0
+277 268 278 0
+-269 -268 0
+-269 -101 0
+268 101 269 0
+-251 137 0
+-251 135 0
+-137 -135 251 0
+-252 251 0
+-252 98 0
+-251 -98 252 0
+-250 144 0
+-250 98 0
+-144 -98 250 0
+-97 58 258  0
+-55 15 0
+-55 11 0
+-15 -11 55 0
+-53 8 0
+-53 3 0
+-8 -3 53 0
+-52 13 0
+-52 7 0
+-13 -7 52 0
+-67 12 0
+-67 4 0
+-12 -4 67 0
+-210 62 0
+-210 28 0
+-62 -28 210 0
+-209 67 0
+-209 28 0
+-67 -28 209 0
+-28 11 0
+-28 3 0
+-11 -3 28 0
+-135 8 0
+-135 5 0
+-8 -5 135 0
+-134 15 0
+-134 13 0
+-15 -13 134 0
+-141 -140 0
+-141 137 0
+140 -137 141 0
+-136 135 0
+-136 134 0
+-135 -134 136 0
+-98 11 0
+-98 5 0
+-11 -5 98 0
+-102 -101 0
+-102 98 0
+101 -98 102 0
+-60 -59 0
+-60 -54 0
+59 54 60 0
+-31 28 51  0
+63 62 66  0
+-33 -32 0
+-33 -27 0
+32 27 33 0
+-21 20 24  0
+-276 -273 0
+-276 134 0
+273 -134 276 0
+-275 -274 0
+-275 -270 0
+274 270 275 0
+-265 251 268  0
+-59 -58 0
+-59 55 0
+58 -55 59 0
+-32 -31 0
+-32 28 0
+31 -28 32 0
+137 135 273  0
+-274 -273 0
+-274 169 0
+273 -169 274 0
+-270 169 0
+-270 134 0
+-169 -134 270 0
+144 98 265  0
+-293 -294 0
+293 294 0
+-251 252 0
+251 -252 0
+-253 255 0
+253 -255 0
+-254 266 0
+254 -266 0
+-176 292 0
+176 -292 0
+c Solver::solve(  )
diff --git a/f4cpp b/f4cpp
deleted file mode 160000
index 645458c..0000000
--- a/f4cpp
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 645458ca02450215bd0e891fc3081d8cbc79c51f
diff --git a/fraig.cpp b/fraig.cpp
new file mode 100644
index 0000000..1e8089f
--- /dev/null
+++ b/fraig.cpp
@@ -0,0 +1,291 @@
+#include "sweep.hpp"
+#include "circuit.hpp"
+#include "src/cadical.hpp"
+extern "C" {
+    #include "aiger.h"
+}
+
+void Sweep::propagate(int* input, int* result) {
+
+    std::queue<int> q;
+
+    for(int i=0; i<aig->num_inputs; i++) {
+        result[aig->inputs[i].lit] = input[i];
+        result[aig->inputs[i].lit+1] = !input[i];
+        q.push(aiger_lit2var(aig->inputs[i].lit));
+    }
+
+    static int* topo_counter = new int[maxvar + 1];
+    memset(topo_counter, 0, (maxvar + 1) * sizeof(int));
+
+    while(!q.empty()) {
+        int cur = q.front();
+        q.pop();
+        for(auto& edge : graph.edge[cur]) {
+            int v = edge.to;
+            topo_counter[v]++;
+
+            if(topo_counter[v] == 2) {
+                q.push(v);
+
+                //cout << "redge: " << v << " " << graph.redge[v][0].to << " " << graph.redge[v][1].to << endl;
+
+                Graph::Edge rhs0_edge = graph.redge[v][0];
+                int rhs0 = aiger_var2lit(rhs0_edge.to);
+
+                Graph::Edge rhs1_edge = graph.redge[v][1];
+                int rhs1 = aiger_var2lit(rhs1_edge.to);
+
+                result[aiger_var2lit(v)] = result[rhs0 + rhs0_edge.neg] & result[rhs1 + rhs1_edge.neg];
+                result[aiger_var2lit(v)+1] = !result[aiger_var2lit(v)];
+
+                //cout << "var: " << aiger_var2lit(v) << " = " << rhs0 + rhs0_edge.neg << " " << rhs1 + rhs1_edge.neg << " : " <<  result[aiger_var2lit(v)] << endl;
+
+            }
+        }
+    }
+}
+
+void Sweep::circuit_propagate(int *input, int* result) {
+    std::queue<int> q;
+
+    for(int i=1; i<=aig->num_inputs; i++) {
+        result[i] = input[i - 1];
+        q.push(i);
+        // printf("%d %d\n", i, result[i]);
+    }
+    for (int i = 1; i <= maxvar; i++) seen[i] = 0;
+    while(!q.empty()) {
+        int x = q.front();
+        q.pop();
+        for (int i = 0; i < inv_C[x].size(); i++) {
+            int v = inv_C[x][i];
+            seen[v]++;
+            if (seen[v] == C[v].sz) {
+                q.push(v);
+                if (C[v].type == And) {
+                    result[v] = 1;
+                    for (int j = 0; j < C[v].sz; j++) {
+                        int x = C[v][j];
+                        result[v] &= x > 0 ? result[abs(x)] : !result[abs(x)];
+                    }
+                }
+                else if (C[v].type == Xor) {
+                    result[v] = 0;
+                    for (int j = 0; j < C[v].sz; j++) {
+                        int x = C[v][j];
+                        result[v] ^= x > 0 ? result[abs(x)] : !result[abs(x)];
+                    }
+                }
+                else if (C[v].type == Majority) {
+                    int s[2] = {0, 0};
+                    for (int j = 0; j < C[v].sz; j++) {
+                        int x = C[v][j];
+                        s[x > 0 ? result[abs(x)] : !result[abs(x)]]++;
+                    }
+                    result[v] = s[1] > s[0] ? 1 : 0;
+                }
+                else if (C[v].type == HA) {
+                    assert(C[v].sz == 2);
+                    int s = 0;
+                    for (int j = 0; j < C[v].sz; j++) {
+                        int x = C[v][j];
+                        s += x > 0 ? result[abs(x)] : !result[abs(x)];
+                    }
+                    result[v] = s % 2;
+                    result[abs(C[v].carrier)] = s >> 1;
+                    if (C[v].carrier < 0) result[abs(C[v].carrier)] = !result[abs(C[v].carrier)];
+                    q.push(abs(C[v].carrier));
+                }
+                else if (C[v].type == FA) {
+                    assert(C[v].sz == 3);
+                    int s = 0;
+                    for (int j = 0; j < C[v].sz; j++) {
+                        int x = C[v][j];
+                        s += x > 0 ? result[abs(x)] : !result[abs(x)];
+                    }
+                    result[v] = s % 2;
+                    result[abs(C[v].carrier)] = s >> 1;
+                    if (C[v].carrier < 0) result[abs(C[v].carrier)] = !result[abs(C[v].carrier)];
+                    q.push(abs(C[v].carrier));
+                }
+                if (C[v].neg) result[v] = !result[v];
+                // printf("%d %d\n", v, result[v]);
+            }
+        }
+    }
+
+}
+
+// int  Sweep::seen_cut_points(aiger* aig, int x, int y) {
+//     std::queue<int> q;
+//     int *used = 
+
+//     x = x & 1 ? -aiger_lit2var(x) : aiger_lit2var(x);
+//     y = y & 1 ? -aiger_lit2var(y) : aiger_lit2var(y);
+
+//     if (!used[abs(x)])
+//         q.push(abs(x)), used[abs(x)] = true;
+//     if(!used[abs(y)])
+//         q.push(abs(y)), used[abs(y)] = true;
+
+// }
+
+bool Sweep::check_var_equal(int x, int y, int assume) {
+
+    std::queue<int> q;
+
+    x = x & 1 ? -aiger_lit2var(x) : aiger_lit2var(x);
+    y = y & 1 ? -aiger_lit2var(y) : aiger_lit2var(y);
+
+    if (!used[abs(x)])
+        q.push(abs(x)), used[abs(x)] = true;
+    if(!used[abs(y)])
+        q.push(abs(y)), used[abs(y)] = true;
+
+    int can_del = 2;
+
+    while(!q.empty()) {
+        int u = q.front();
+        q.pop();
+
+        /*
+        (u => a & b) <=> ~u | (a & b) <=> (~u | a) & (~u | b)
+        (u <= a & b) <=> ~(a & b) | u <=> ~a | ~b | u
+        */
+        if(graph.redge[u].size() == 0) continue;
+
+        int a = graph.redge[u][0].to;
+        int b = graph.redge[u][1].to;
+
+        //cout << "AND " << aiger_var2lit(u) << " " << (aiger_var2lit(a) + graph.redge[u][0].neg) << " " << (aiger_var2lit(b) + graph.redge[u][1].neg) << endl;
+
+        if(graph.redge[u][0].neg) a = -a;
+        if(graph.redge[u][1].neg) b = -b;
+        
+
+        solver->add(-u), solver->add( a), solver->add(0);
+        solver->add(-u), solver->add( b), solver->add(0);
+        solver->add(-a), solver->add(-b), solver->add(u), solver->add(0);
+
+        a = abs(a), b = abs(b);
+
+        if(!used[a])
+            q.push(a), used[a] = true, can_del++;
+
+        if(!used[b])
+            q.push(b), used[b] = true, can_del++;
+    }
+
+    //Assume -NV
+    solver->add(-assume), solver->add(-x), solver->add(-y), solver->add(0);
+    solver->add(-assume), solver->add(x), solver->add(y), solver->add(0);
+
+    solver->assume (assume);
+
+    int result = solver->solve ();  
+
+    // if (result == 20) printf("can delete %d vars\n", can_del);
+    return result == 20;
+}
+
+bool Sweep::check_constant(int x, int val) {
+
+    std::queue<int> q;
+    x = x & 1 ? -aiger_lit2var(x) : aiger_lit2var(x);
+
+    if (!used[abs(x)]) q.push(abs(x)), used[abs(x)] = true;
+
+    while(!q.empty()) {
+        int u = q.front();
+        q.pop();
+
+        if(graph.redge[u].size() == 0) continue;
+
+        int a = graph.redge[u][0].to;
+        int b = graph.redge[u][1].to;
+        if(graph.redge[u][0].neg) a = -a;
+        if(graph.redge[u][1].neg) b = -b;
+
+        solver->add(-u), solver->add( a), solver->add(0);
+        solver->add(-u), solver->add( b), solver->add(0);
+        solver->add(-a), solver->add(-b), solver->add(u), solver->add(0);
+
+        a = abs(a), b = abs(b);
+
+        if(!used[a]) q.push(a), used[a] = true;
+        if(!used[b]) q.push(b), used[b] = true;
+    }
+
+    solver->assume (x * (val ? -1 : 1));
+
+    int result = solver->solve();  
+    return result == 20;
+}
+
+void Sweep::random_simulation() {
+    
+    int* result = new int[2 * maxvar + 2];
+    int* circuit_res = new int[maxvar + 1];
+    int* input_vector = new int[aig->num_inputs];
+
+    for(int i=0; i<rounds; i++) 
+    {
+        if (i % 10000 == 0) printf("================================= %d ===========================\n", i);
+        for(int i=0; i<aig->num_inputs; i++) {
+            input_vector[i] = rand() % 2;
+        }
+        for (int i=0; i<det_v_sz; i++) {
+            if (abs(det_v[i]) <= aig->num_inputs) input_vector[abs(det_v[i]) - 1] = det_v[i] > 0 ? 1 : 0;
+        }
+        memset(result, -1, (2 * maxvar + 2) * sizeof(int));
+        memset(circuit_res, -1, (maxvar + 1) * sizeof(int));
+
+        propagate(input_vector, result);
+        circuit_propagate(input_vector, circuit_res);
+        if (result[output] != !circuit_res[output >> 1]) {
+            printf("wrong %d %d %d\n", output, !result[output], circuit_res[output >> 1]);
+            for (int i = 1; i <= maxvar; i++) {
+                if (circuit_res[i] == -1) continue;
+                if (result[i * 2] != circuit_res[i]) printf("%d %d %d\n", i, result[i * 2], circuit_res[i]);
+                printf("%d %d\n", i, result[i << 1]);
+            }
+            return;
+        }
+        std::vector<std::vector<int>> tmp;
+        for(auto& clas : classes) {
+            std::vector<int> v0;
+            std::vector<int> v1;
+            for(auto &v : clas) {
+                if(result[v]) v1.push_back(v), sum_pos[v] += 1;
+                else v0.push_back(v), sum_neg[v] += 1;
+            }
+            if(v0.size() > 1) tmp.push_back(v0);
+            if(v1.size() > 1) tmp.push_back(v1);
+        }
+        
+        classes = tmp;
+    }
+    printf("c Number of equivalent classes: %d\n", classes.size());
+    // printf("classes: \n");
+    // for(auto& clas : classes) {
+    //     int lit = clas[0];
+    //     printf("[ ");
+    //     for(auto &v : clas) {
+    //         printf("%d ", v);
+    //     }
+    //     printf("] %d %d\n", sum_pos[lit], sum_neg[lit]);
+    // }
+
+}
+
+void Sweep::simulation() {
+    //printf("c =================================== detect =================================\n");    
+    seen = new int[maxvar + 1];
+    classes.push_back(std::vector<int>());
+    for(int i=2; i<=maxvar*2+1; i++) {
+        classes[0].push_back(i);
+    }
+   
+    random_simulation();
+}
\ No newline at end of file
diff --git a/hCaD_V2/BUILD.md b/hCaD_V2/BUILD.md
new file mode 100644
index 0000000..8804f3f
--- /dev/null
+++ b/hCaD_V2/BUILD.md
@@ -0,0 +1,104 @@
+# CaDiCaL Build
+
+Use `./configure && make` to configure and build `cadical` in the default
+`build` sub-directory.
+
+This will also build the library `libcadical.a` as well as the model based
+tester `mobical`:
+  
+    build/cadical
+    build/mobical
+    build/libcadical.a
+
+The header file of the library is in
+
+    src/cadical.hpp
+
+The build process requires GNU make.  Using the generated `makefile` with
+GNU make compiles separate object files, which can be cached (for instance
+with `ccache`).  In order to force parallel build you can use the '-j'
+option either for 'configure' or with 'make'.  If the environment variable
+'MAKEFLAGS' is set, e.g., 'MAKEFLAGS=-j ./configure', the same effect
+is achieved and the generated makefile will use those flags.
+
+Options
+-------
+
+You might want to check out options of `./configure -h`, such as
+
+    ./configure -c # include assertion checking code
+
+    ./configure -l # include code to really see what the solver is doing
+
+    ./configure -a # both above and in addition `-g` for debugging.
+
+You can easily use multiple build directories, e.g.,
+
+    mkdir debug; cd debug; ../configure -g; make
+
+which compiles and builds a debugging version in the sub-directory `debug`,
+since `-g` was specified as parameter to `configure`.  The object files,
+the library and the binaries are all independent of those in the default
+build directory `build`.
+
+All source files reside in the `src` directory.  The library `libcadical.a`
+is compiled from all the `.cpp` files except `cadical.cpp` and
+`mobical.cpp`, which provide the applications, i.e., the stand alone solver
+`cadical` and the model based tester `mobical`.
+
+Manual Build
+------------
+
+If you can not or do not want to rely on our `configure` script nor on our
+build system based on GNU `make`, then this is easily doable as follows.
+
+    mkdir build
+    cd build
+    for f in ../src/*.cpp; do g++ -O3 -DNDEBUG -DNBUILD -c $f; done
+    ar rc libcadical.a `ls *.o | grep -v ical.o`
+    g++ -o cadical cadical.o -L. -lcadical
+    g++ -o mobical mobical.o -L. -lcadical
+
+Note that application object files are excluded from the library.
+Of course you can use different compilation options as well.
+  
+Since `build.hpp` is not generated in this flow the `-DNBUILD` flag is
+necessary though, which avoids dependency of `version.cpp` on `build.hpp`.
+Consequently you will only get very basic version information compiled into
+the library and binaries (guaranteed is in essence just the version number
+of the library).
+
+And if you really do not care about compilation time nor caching and just
+want to build the solver once manually then the following also works.
+
+    g++ -O3 -DNDEBUG -DNBUILD -o cadical `ls *.cpp | grep -v mobical`
+
+Further note that the `configure` script provides some feature checks and
+might generate additional compiler flags necessary for compilation.  You
+might need to set those yourself or just use a modern C++11 compiler.
+
+This manual build process using object files is fast enough in combination
+with caching solutions such as `ccache`.  But it lacks the ability of our
+GNU make solution to run compilation in parallel without additional parallel
+process scheduling solutions.
+
+Cross-Compilation
+-----------------
+
+We have preliminary support for cross-compilation using MinGW32 (only
+tested for a Linux compilation host and Windows-64 target host at this
+point).
+
+There are two steps necessary to make this work.  First make
+sure to be able to execute binaries compiled with the cross-compiler
+directly.  For instance in order to use `wine` to execute the binaries
+on Linux you might want to look into the `binfmt_misc` module and
+registering the appropriate interpreter for `DOSWin`. As second step
+you simply tell the `configure` script to use the cross-compiler.
+
+    CXXFLAGS=-static CXX=i686-w64-mingw32-g++ ./configure
+
+Note the use of '-static', which was necessary for me since by default
+`wine` did not find `libstdc++` if dynamically linked.
+
+
diff --git a/hCaD_V2/CONTRIBUTING b/hCaD_V2/CONTRIBUTING
new file mode 100644
index 0000000..fbf1cdd
--- /dev/null
+++ b/hCaD_V2/CONTRIBUTING
@@ -0,0 +1,4 @@
+At this point we want to keep complete ownership in one hand
+to particularly avoid any additional co-authorship claims.
+Thus please refrain from generating pull requests.  Use the issue
+tracker or send email to 'biere@jku.at' instead.
diff --git a/hCaD_V2/LICENSE b/hCaD_V2/LICENSE
new file mode 100644
index 0000000..81065ff
--- /dev/null
+++ b/hCaD_V2/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2016-2021 Armin Biere, Johannes Kepler University Linz, Austria
+Copyright (c) 2020-2021 Mathias Fleury, Johannes Kepler University Linz, Austria
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/hCaD_V2/README.md b/hCaD_V2/README.md
new file mode 100644
index 0000000..756f3b8
--- /dev/null
+++ b/hCaD_V2/README.md
@@ -0,0 +1,54 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build Status](https://travis-ci.com/arminbiere/cadical.svg?branch=master)](https://travis-ci.com/arminbiere/cadical)
+
+
+CaDiCaL Simplified Satisfiability Solver
+===============================================================================
+
+The goal of the development of CaDiCaL was to obtain a CDCL solver,
+which is easy to understand and change, while at the same time not being
+much slower than other state-of-the-art CDCL solvers.
+
+Originally we wanted to also radically simplify the design and internal data
+structures, but that goal was only achieved partially, at least for instance
+compared to Lingeling.
+
+However, the code is much better documented and CaDiCaL actually became in
+general faster than Lingeling even though it is missing some preprocessors
+(mostly parity and cardinality constraint reasoning), which would be crucial
+to solve certain instances.
+
+Use `./configure && make` to configure and build `cadical` and the library
+`libcadical.a` in the default `build` sub-directory.  The header file of
+the library is [`src/cadical.hpp`](src/cadical.hpp) and includes an example
+for API usage.
+  
+See [`BUILD.md`](BUILD.md) for options and more details related to the build
+process and [`test/README.md`](test/README.md) for testing the library and
+the solver.
+
+The solver has the following usage `cadical [ dimacs [ proof ] ]`.
+See `cadical -h` for more options.
+
+If you want to cite CaDiCaL please use the solver description in the
+latest SAT competition proceedings:
+
+<pre>
+  @inproceedings{BiereFazekasFleuryHeisinger-SAT-Competition-2020-solvers,
+    author    = {Armin Biere and Katalin Fazekas and Mathias Fleury and Maximillian Heisinger},
+    title     = {{CaDiCaL}, {Kissat}, {Paracooba}, {Plingeling} and {Treengeling}
+		 Entering the {SAT Competition 2020}},
+    pages     = {51--53},
+    editor    = {Tomas Balyo and Nils Froleyks and Marijn Heule and 
+		 Markus Iser and Matti J{\"a}rvisalo and Martin Suda},
+    booktitle = {Proc.~of {SAT Competition} 2020 -- Solver and Benchmark Descriptions},
+    volume    = {B-2020-1},
+    series    = {Department of Computer Science Report Series B},
+    publisher = {University of Helsinki},
+    year      = 2020,
+  }
+</pre>
+
+You might also find more information on CaDiCaL at <http://fmv.jku.at/cadical>.
+
+Armin Biere
diff --git a/hCaD_V2/VERSION b/hCaD_V2/VERSION
new file mode 100644
index 0000000..347f583
--- /dev/null
+++ b/hCaD_V2/VERSION
@@ -0,0 +1 @@
+1.4.1
diff --git a/hCaD_V2/bin/starexec_run_default b/hCaD_V2/bin/starexec_run_default
new file mode 100644
index 0000000..d24f815
--- /dev/null
+++ b/hCaD_V2/bin/starexec_run_default
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./cadical --target=0 --walk=false $1 $2/proof.out
diff --git a/hCaD_V2/configure b/hCaD_V2/configure
new file mode 100755
index 0000000..e761d26
--- /dev/null
+++ b/hCaD_V2/configure
@@ -0,0 +1,494 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+# Run './configure' to produce a 'makefile' in the 'build' sub-directory or
+# in any immediate sub-directory different from the 'src', 'scripts' and
+# 'test' directories.
+
+#--------------------------------------------------------------------------#
+
+rm -f configure.log
+
+#--------------------------------------------------------------------------#
+
+# Common default options.
+
+all=no
+debug=no
+logging=no
+check=no
+competition=no
+coverage=no
+profile=no
+contracts=yes
+tracing=yes
+unlocked=yes
+pedantic=no
+options=""
+quiet=no
+m32=no
+
+#--------------------------------------------------------------------------#
+
+if [ -f ./scripts/colors.sh ]
+then
+  . ./scripts/colors.sh
+elif [ -f ../scripts/colors.sh ]
+then
+  . ../scripts/colors.sh
+else
+  BAD=""
+  HILITE=""
+  BOLD=""
+  NORMAL=""
+fi
+
+die () {
+  if [ -f configure.log ]
+  then
+    checklog=" (check also 'configure.log')"
+  else
+    checklog=""
+  fi
+  cecho "${BOLD}configure:${NORMAL} ${BAD}error:${NORMAL} $*${checklog}"
+  exit 1
+}
+
+msg () {
+  cecho "${BOLD}configure:${NORMAL} $*"
+}
+
+# if we can find the 'color.sh' script source it and overwrite color codes
+
+for dir in . ..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+# Parse and handle command line options.
+
+usage () {
+cat << EOF
+usage: configure [ <option> ... ]
+
+where '<option>' is one of the following
+
+-h|--help          print this command line summary
+-g|--debug         compile with debugging information
+-c|--check         compile with assertion checking (default for '-g')
+-l|--log[ging]     include logging code (but disabled by default)
+-a|--all           short cut for all above, e.g., '-g -l' (thus also '-c')
+-q|--quiet         exclude message and profiling code (logging too)
+-p|--pedantic      add '--pedantic' and '-Werror' compilation flag
+-s|--symbols       add '-ggdb3' (even for optimized compilation)
+
+--coverage         compile with '-ftest-coverage -fprofile-arcs' for 'gcov'
+--profile          compile with '-pg' to profile with 'gprof'
+
+--no-contracts     compile without API contract checking code
+--no-tracing       compile without API call tracing code
+
+--competition      configure for the competition
+                   ('--quiet', '--no-contracts', '--no-tracing')
+
+-f...              pass '-f<option>[=<val>]' options to the makefile
+-m32               pass '-m32' to the compiler (compile for 32 bit)
+-ggdb3             pass '-ggdb3' to makefile (like '-s')
+-O|-O[123]         pass '-O' or '-O[123]' to the makefile
+-static...         pass '-static...' option to makefile
+
+The environment variable CXX can be used to set a different C++
+compiler than the default 'g++'.  Similarly you can add additional
+compilation options by setting CXXFLAGS.  For example
+
+  CXX=clang++ CXXFLAGS=-fPIC ./configure
+
+will enforce to use 'clang++' as C++ compiler and also produce
+position independent code.  In order to be shell independent we also
+allow to have the following form.  Thus for instance
+
+  ./configure CXX="g++-8" CXXFLAGS="-fPIC -fsanitize=address"
+
+will have the same effect as
+
+  CXX="g++-8" ./configure -fPIC -fsanitize=address
+
+The following configuration options might be usefull during porting the
+code to a new platform and are usually not necessary to change.
+
+--no-unlocked      force compilation without unlocked IO
+EOF
+exit 0
+}
+
+#--------------------------------------------------------------------------#
+
+while [ $# -gt 0 ]
+do
+  case $1 in
+
+    -h|--help) usage;;
+
+    -a|--all) all=yes;;
+
+    -g|--debug) debug=yes;;
+    -c|--check) check=yes;;
+    -l|--log|--logging) logging=yes;;
+
+    -p|--pedantic) pedantic=yes;;
+    -q|--quiet) quiet=yes;;
+
+    --no-contracts | --no-contract) contracts=no;;
+    --no-tracing | --no-trace) tracing=no;;
+
+    --coverage) coverage=yes;;
+    --profile) profile=yes;;
+
+    --competition) competition=yes;;
+
+    --no-unlocked) unlocked=no;;
+
+    -m32) options="$options $1";m32=yes;;
+    -f*|-ggdb3|-O|-O1|-O2|-O3) options="$options $1";;
+    -s|--symbols) options="$options -ggdb3";;
+    -static*) options="$options $1";;
+
+    CXX=*)
+      CXX="`expr \"$1\" : 'CXX=\(.*\)'`"
+      ;;
+
+    CXXFLAGS=*)
+      CXXFLAGS="`expr \"$1\" : 'CXXFLAGS=\(.*\)'`"
+      ;;
+
+    *) die "invalid option '$1' (try '-h')";;
+
+  esac
+  shift
+done
+
+#--------------------------------------------------------------------------#
+
+if [ $quiet = yes ]
+then
+  [ $logging = yes ] && die "can not combine '-q' with '-l'"
+fi
+
+if [ $all = yes ]
+then
+  [ $check = yes ] && die "'-a' subsumes '-c'"
+  [ $debug = yes ] && die "'-a' subsumes '-g'"
+  [ $logging = yes ] && die "'-a' subsumes '-l'"
+  check=yes
+  debug=yes
+  logging=yes
+elif [ $debug = yes ]
+then
+  [ $check = yes ] && die "'-g' subsumes '-c'"
+  check=yes
+fi
+
+#--------------------------------------------------------------------------#
+
+# Generate and enter 'build' directory if not already in sub-directory.
+
+build_in_default_build_sub_directory () {
+  if [ -d build ]
+  then
+    msg "reusing default 'build' directory"
+  else
+    mkdir build 2>/dev/null || \
+    die "failed to generate 'build' directory"
+    msg "making default 'build' directory"
+  fi
+  cd build
+  msg "building in default ${HILITE}'`pwd`'${NORMAL}"
+  build=build
+}
+
+if [ -f configure -a -f makefile.in -a -d src ]
+then
+  root="`pwd`"
+  build_in_default_build_sub_directory
+elif [ -f ../configure -a -f ../makefile.in -a -d ../src ]
+then
+  cwd="`pwd`"
+  build=`basename "$cwd"`
+  root=`dirname "$cwd"`
+  case x"$build" in
+    xsrc|xtest|xscripts)
+      cd ..
+      build_in_default_build_sub_directory
+      ;;
+    *)
+      msg "building in ${HILITE}'$build'${NORMAL} sub-directory"
+      ;;
+  esac
+else
+  die "call 'configure' from root of CaDiCaL source or a sub-directory"
+fi
+
+msg "root directory '$root'"
+
+#--------------------------------------------------------------------------#
+
+src="$root/src"
+
+if [ -d "$src" ]
+then
+  msg "source directory '$src'"
+else
+  die "could not find source director '$src'"
+fi
+
+#--------------------------------------------------------------------------#
+
+# Prepare '@CXX@' and '@CXXFLAGS@' parameters for 'makefile.in'
+
+[ x"$CXX" = x ] && CXX=g++
+[ x"$CXXFLAGS" = x ] || CXXFLAGS="$CXXFLAGS "
+
+case x"$CXX" in
+  x*g++*|x*clang++*) CXXFLAGS="${CXXFLAGS}-Wall -Wextra";;
+  *) CXXFLAGS="${CXXFLAGS}-W";;
+esac
+
+if [ $debug = yes ]
+then
+  CXXFLAGS="$CXXFLAGS -g"
+else
+  case x"$CXX" in
+    x*g++*|x*clang++*) CXXFLAGS="$CXXFLAGS -O3";;
+    *) CXXFLAGS="$CXXFLAGS -O";;
+  esac
+fi
+
+if [ $m32 = yes ]
+then
+  case x"$CXX" in
+    x*g++*)
+      options="$options -mpc64"
+      msg "forcing portable 64-bit FPU mode ('-mpc64') for '$CXX'"
+      ;;
+  esac
+fi
+
+if [ $competition = yes ]
+then
+  quiet=yes
+  contracts=no
+  tracing=no
+fi
+
+[ $check = no ] && CXXFLAGS="$CXXFLAGS -DNDEBUG"
+[ $logging = yes ] && CXXFLAGS="$CXXFLAGS -DLOGGING"
+[ $quiet = yes ] && CXXFLAGS="$CXXFLAGS -DQUIET"
+[ $profile = yes ] && CXXFLAGS="$CXXFLAGS -pg"
+[ $coverage = yes ] && CXXFLAGS="$CXXFLAGS -ftest-coverage -fprofile-arcs"
+if [ $pedantic = yes ]
+then
+  CXXFLAGS="$CXXFLAGS --pedantic -Werror -std=c++11"
+  case x"$CXX" in
+    x*g++*|x*clang++*) CXXFLAGS="${CXXFLAGS} -Wp,-D_GLIBCXX_ASSERTIONS"
+    ;;
+  esac
+fi
+[ $contracts = no ] && CXXFLAGS="$CXXFLAGS -DNCONTRACTS"
+[ $tracing = no ] && CXXFLAGS="$CXXFLAGS -DNTRACING"
+
+CXXFLAGS="$CXXFLAGS$options"
+
+#--------------------------------------------------------------------------#
+
+case x"$CXX" in
+  x*g++* | x*clang++*) WERROR="-Werror -pedantic";;
+  *) WERROR="";;
+esac
+
+# Check that compilation flags work.
+
+feature=./configure-hello-world
+cat <<EOF > $feature.cpp
+#include <iostream>
+int main () { std::cout << "hello world" << std::endl; }
+EOF
+if $CXX $CXXFLAGS $WERROR -o $feature.exe $feature.cpp 2>>configure.log
+then
+  if [ ! "`$feature.exe 2>>configure.log|tr -d '\r'`" = "hello world" ]
+  then
+    die "execution of '$feature.exe' failed"
+  fi
+else
+  die "test compilation '$feature.cpp'"
+fi
+
+#--------------------------------------------------------------------------#
+
+# Since C99/C++11 is becoming the standard newer versions of 'g++' (7.3 for
+# instance) discourage certain GCC extensions, particularly the GCC version
+# of variadic macros, if the same concept exists in the standard.  This
+# forced us to replace all GCC style 'ARGS...' macros with '...' and
+# '__VA_ARGS__'.  Otherwise compiling the library with '--pedantic -Werror'
+# would fail (configuration flag '-p').  However, older versions of 'gcc'
+# (such as 4.8) would disallow these new forms of macros unless we
+# explicitly enforce the new standard with '-std=c++11'.  Here we try to
+# figure out whether we need that flag.  In earlier versions we used
+# '-std=c++0x' but due to issues with older MacOS builds we switched to
+# '-std=c++11' instead.
+
+feature=./configure-requires-c++11
+cat <<EOF > $feature.cpp
+#include <cstdio>
+#include <vector>
+
+// old variadic macro usage 'ARGS...' / '#ARGS' discouraged in g++-7...
+// new variadic macro usage '...' / '__VA_ARGS__' available in C99/C++11
+//
+#define MACRO(FMT, ...) printf (FMT "\n", __VA_ARGS__)
+
+// we use ranged for loops which became available in gcc 4.6 and for
+// the gcc 4.6 as well as 4.8 requires '-std=c++11' too.
+//
+unsigned f (const std::vector<unsigned> & a) {
+  unsigned res = 0;
+  for (auto i : a) res += i;
+  return res;
+}
+
+
+int main () { MACRO ("%d", 42); return 0; }
+EOF
+if $CXX $CXXFLAGS $WERROR -o $feature.exe $feature.cpp 2>>configure.log
+then
+  if [ "`$feature.exe 2>>configure.log|tr -d '\r'`" = 42 ]
+  then
+    msg "compiler supports all required C99/C++11 extensions"
+  else
+    die "checking compilation without '-std=c++11' failed"
+  fi
+else
+  CXXFLAGS="$CXXFLAGS -std=c++11"
+  if $CXX $CXXFLAGS -o $feature.exe $feature.cpp 2>>configure.log
+  then
+    if [ "`$feature.exe 2>>configure.log|tr -d '\r'`" = 42 ]
+    then
+      msg "using '-std=c++11' for all required C99/C++11 extensions"
+    else
+      die "checking compilation with '-std=c++11' failed"
+    fi
+  else
+    die "compiler does not support C99/C++11 even with '-std=c++11'"
+  fi
+fi
+
+#--------------------------------------------------------------------------#
+
+# Unlocked IO is much faster but not necessarily supported.
+
+if [ $unlocked = yes ]
+then
+  feature=./configure-have-unlocked-io
+cat <<EOF > $feature.cpp
+#include <cstdio>
+int main () {
+  const char * path = "$feature.log";
+  FILE * file = fopen (path, "w");
+  if (!file) return 1;
+  if (putc_unlocked (42, file) != 42) return 1;
+  if (fclose (file)) return 1;
+  file = fopen (path, "r");
+  if (!file) return 1;
+  if (getc_unlocked (file) != 42) return 1;
+  if (fclose (file)) return 1;
+  return 0;
+}
+EOF
+  if $CXX $CXXFLAGS -o $feature.exe $feature.cpp 2>>configure.log
+  then
+    if $feature.exe
+    then
+      msg "unlocked IO with '{putc,getc}_unlocked' seems to work"
+    else
+      msg "not using unlocked IO (running '$feature.exe' failed)"
+      unlocked=no
+    fi
+  else
+    msg "not using unlocked IO (failed to compile '$feature.cpp')"
+    unlocked=no
+  fi
+else
+  msg "not using unlocked IO (since '--no-unlocked' specified)"
+fi
+
+[ $unlocked = no ] && CXXFLAGS="$CXXFLAGS -DNUNLOCKED"
+
+#--------------------------------------------------------------------------#
+
+# Instantiate '../makefile.in' template to produce 'makefile' in 'build'.
+
+msg "compiling with ${HILITE}'$CXX $CXXFLAGS'${NORMAL}"
+
+rm -f makefile
+sed \
+-e "2c\\
+# This 'makefile' is generated from '../makefile.in'." \
+-e "s,@CXX@,$CXX," \
+-e "s#@CXXFLAGS@#$CXXFLAGS#" \
+../makefile.in > makefile
+
+msg "generated '$build/makefile' from '../makefile.in'"
+
+#--------------------------------------------------------------------------#
+
+build="`pwd`"
+makefile="`dirname "$build"`/makefile"
+cat <<EOF > "$makefile"
+CADICALBUILD=$build
+all:
+	\$(MAKE) -C "\$(CADICALBUILD)"
+clean:
+	@if [ -d "\$(CADICALBUILD)" ]; \\
+	then \\
+	  if [ -f "\$(CADICALBUILD)"/makefile ]; \\
+	  then \\
+	     touch "\$(CADICALBUILD)"/build.hpp; \\
+	     \$(MAKE) -C "\$(CADICALBUILD)" clean; \\
+	  fi; \\
+	  rm -rf "\$(CADICALBUILD)"; \\
+	fi
+	rm -f "$src/makefile"
+	rm -f "$makefile"
+test:
+	\$(MAKE) -C "\$(CADICALBUILD)" test
+cadical:
+	\$(MAKE) -C "\$(CADICALBUILD)" cadical
+mobical:
+	\$(MAKE) -C "\$(CADICALBUILD)" mobical
+update:
+	\$(MAKE) -C "\$(CADICALBUILD)" update
+.PHONY: all cadical clean mobical test update
+EOF
+
+msg "generated '../makefile' as proxy to ..."
+msg "... '$build/makefile'"
+
+#--------------------------------------------------------------------------#
+
+if [ -f $src/makefile ]
+then
+  msg "removing '$src/makefile'"
+  rm -f $src/makefile
+fi
+
+msg "linking '$root/makefile'"
+ln -s $root/makefile $src/makefile
+
+#--------------------------------------------------------------------------#
+
+msg "now run ${HILITE}'make'${NORMAL} to compile CaDiCaL"
+msg "optionally run 'make test'"
diff --git a/hCaD_V2/makefile b/hCaD_V2/makefile
new file mode 100644
index 0000000..be740b8
--- /dev/null
+++ b/hCaD_V2/makefile
@@ -0,0 +1,24 @@
+CADICALBUILD=/home/chenzh/experiments/cec/equal/hCaD_V2/build
+all:
+	$(MAKE) -C "$(CADICALBUILD)"
+clean:
+	@if [ -d "$(CADICALBUILD)" ]; \
+	then \
+	  if [ -f "$(CADICALBUILD)"/makefile ]; \
+	  then \
+	     touch "$(CADICALBUILD)"/build.hpp; \
+	     $(MAKE) -C "$(CADICALBUILD)" clean; \
+	  fi; \
+	  rm -rf "$(CADICALBUILD)"; \
+	fi
+	rm -f "/home/chenzh/experiments/cec/equal/hCaD_V2/src/makefile"
+	rm -f "/home/chenzh/experiments/cec/equal/hCaD_V2/makefile"
+test:
+	$(MAKE) -C "$(CADICALBUILD)" test
+cadical:
+	$(MAKE) -C "$(CADICALBUILD)" cadical
+mobical:
+	$(MAKE) -C "$(CADICALBUILD)" mobical
+update:
+	$(MAKE) -C "$(CADICALBUILD)" update
+.PHONY: all cadical clean mobical test update
diff --git a/hCaD_V2/makefile.in b/hCaD_V2/makefile.in
new file mode 100644
index 0000000..69b4d22
--- /dev/null
+++ b/hCaD_V2/makefile.in
@@ -0,0 +1,84 @@
+#==========================================================================#
+# This is a 'makefile.in' template with '@CXX@' and '@CXXFLAGS@' parameters.
+# This makefile requires GNU make.
+#==========================================================================#
+
+# The '../scripts/make-build-header.sh' script searches for the next two
+# lines to figure out the compiler and compilation flags.  This information
+# is then used to generate corresponding macros in 'build.hpp'.
+
+CXX=@CXX@
+CXXFLAGS=@CXXFLAGS@
+
+############################################################################
+#    It is usually not necessary to change anything below this line!       #
+############################################################################
+
+APP=cadical.cpp mobical.cpp
+SRC=$(sort $(wildcard ../src/*.cpp))
+SUB=$(subst ../src/,,$(SRC))
+LIB=$(filter-out $(APP),$(SUB))
+OBJ=$(LIB:.cpp=.o)
+DIR=../$(shell pwd|sed -e 's,.*/,,')
+COMPILE=$(CXX) $(CXXFLAGS) -I$(DIR)
+
+#--------------------------------------------------------------------------#
+
+all: libcadical.a cadical mobical
+
+#--------------------------------------------------------------------------#
+
+.SUFFIXES: .cpp .o
+
+%.o: ../src/%.cpp ../src/*.hpp makefile
+	$(COMPILE) -c $<
+
+#--------------------------------------------------------------------------#
+
+# Application binaries (the stand alone solver 'cadical' and the model based
+# tester 'mobical') and the library are the main build targets.
+
+cadical: cadical.o libcadical.a makefile
+	$(COMPILE) -o $@ $< -L. -lcadical
+
+mobical: mobical.o libcadical.a makefile
+	$(COMPILE) -o $@ $< -L. -lcadical
+
+libcadical.a: $(OBJ) makefile
+	ar rc $@ $(OBJ)
+
+#--------------------------------------------------------------------------#
+
+# Note that 'build.hpp' is generated and resides in the build directory.
+
+build.hpp: always
+	../scripts/make-build-header.sh > build.hpp
+
+version.o: build.hpp
+
+update:
+	../scripts/update-version.sh
+
+#--------------------------------------------------------------------------#
+
+# These two 'C' interfaces include '.h' headers and thus require explicitly
+# defined additional dependencies.
+
+ccadical.o: ../src/ccadical.h
+ipasir.o: ../src/ipasir.h ../src/ccadical.h
+
+#--------------------------------------------------------------------------#
+
+analyze: all
+	$(COMPILE) --analyze ../src/*.cpp
+
+clean:
+	rm -f *.o *.a cadical mobical makefile build.hpp
+	rm -f *.gcda *.gcno *.gcov gmon.out
+
+test: all
+	CADICALBUILD="$(DIR)" $(MAKE) -j1 -C ../test
+
+#--------------------------------------------------------------------------#
+
+.PHONY: all always analyze clean test update
diff --git a/hCaD_V2/scripts/README.md b/hCaD_V2/scripts/README.md
new file mode 100644
index 0000000..bc7bb5a
--- /dev/null
+++ b/hCaD_V2/scripts/README.md
@@ -0,0 +1,42 @@
+# CaDiCaL Scripts
+
+Scripts needed for the build process
+
+    ./make-build-header.sh   # generates 'build.hpp'
+    ./get-git-id.sh          # get GIT id (needed by 'make-build-header.sh')
+    ./update-version.sh      # synchronizes VERSION in '../src/version.cpp'
+
+and a script which builds and tests all configurations
+
+    ./build-and-test-all-configurations.sh
+    CXX=clang++ ./build-and-test-all-configurations.sh
+    CXX=g++-4.8 ./build-and-test-all-configurations.sh
+
+where as the code shows the compiler (default `g++`) is specified through
+the environment variable `CXX` (as for `../configure`).  Then there are
+scripts for producing a source release
+
+    ./make-src-release.sh          # archive as 'cadical-VERSION-GITID.tar.xz'
+    ./prepare-sc2021-submission.sh # star-exec format for SAT competition
+
+and scripts for testing and debugging
+
+    ./generate-embedded-options-default-list.sh # in 'c --opt=val' format
+    ./generate-options-range-list.sh            # 'cnfuzz' option file format
+    ./run-cadical-and-check-proof.sh            # wrapper to check proofs too
+    ./run-simplifier-and-extend-solution.sh     # to check simplifier
+    ./extend-solution.sh                        # called by previous script
+
+a script to check whether all options are actually used
+
+    ./check-options-occur.sh
+
+a script to update the example in the `../src/cadical.hpp` header
+
+    ./update-example-in-cadical-header-file.sh
+
+and finally a script to normalize white space of the source code
+
+    ./normalize-white-space.sh
+
+The `color.sh` script is used by the `run.sh` scripts in `test`.
diff --git a/hCaD_V2/scripts/build-and-test-all-configurations.sh b/hCaD_V2/scripts/build-and-test-all-configurations.sh
new file mode 100755
index 0000000..fafc880
--- /dev/null
+++ b/hCaD_V2/scripts/build-and-test-all-configurations.sh
@@ -0,0 +1,115 @@
+#!/bin/sh
+
+. `dirname $0`/colors.sh || exit 1
+
+############################################################################
+
+die () {
+  echo "build-and-test-all-configurations.sh: ${BAD}error${NORMAL}: $*" 1>&2
+  exit 1
+}
+
+############################################################################
+
+if [ -f configure ]
+then
+  configure="./configure"
+  makeoptions=""
+elif [ -f ../configure ]
+then
+  configure="../configure"
+  makeoptions=" -C .."
+else
+  die "Can not find 'configure'."
+fi
+
+if [ "$CXX" = "" ]
+then
+  environment=""
+else
+  environment="CXX=$CXX "
+fi
+
+if [ ! "$CXXFLAGS" = "" ]
+then
+  [ "$environment" = "" ] || environment="$environment "
+  environment="${environment}CXXFLAGS=\"$CXXFLAGS\" "
+fi
+
+############################################################################
+
+ok=0
+
+run () {
+  if [ "$*" = "" ]
+  then
+    configureoptions=""
+    description="<empty>"
+  else
+    configureoptions=" $*"
+    description="$*"
+  fi
+  echo "$environment$configure$configureoptions && make$makeoptions test"
+  $configure$configureoptions $* >/dev/null 2>&1 && \
+  make$makeoptions test >/dev/null 2>&1
+  test $? = 0 || die "Configuration \`$description' failed."
+  make$makeoptions clean >/dev/null 2>&1
+  test $? = 0 || die "Cleaning up for \`$description' failed."
+  ok=`expr $ok + 1`
+}
+
+############################################################################
+
+# start with these two for fast fail
+
+run		# default configuration (depends on 'MAKEFLAGS'!)
+run -p		# then check default pedantic first
+
+run -q		# library users might want to disable messages
+run -q -p	# also check '--quiet' pedantically
+
+# now start with the five single options
+
+run -a		# actually enables all the four next options below
+run -c
+run -g
+run -l
+
+# all five single options pedantically
+
+run -a -p
+run -c -p
+run -g -p
+run -l -p
+
+# all legal pairs of single options
+# ('-a' can not be combined with any of the other options)
+# ('-g' can not be combined '-c')
+
+run -c -l
+run -c -q
+run -g -l
+run -g -q
+
+# the same pairs but now with pedantic compilation
+
+run -c -l -p
+run -c -q -p
+run -g -l -p
+run -g -q -p
+
+# finally check that these also work to some extend
+
+run -m32 -q
+run -m32 -a -p
+
+run --no-unlocked -q
+run --no-unlocked -a -p
+
+run --no-contracts -q
+run --no-contracts -a -p
+
+run --no-tracing -q
+run --no-tracing -a -p
+
+echo "successfully compiled and tested ${GOOD}${ok}${NORMAL} configurations"
diff --git a/hCaD_V2/scripts/check-options-occur.sh b/hCaD_V2/scripts/check-options-occur.sh
new file mode 100755
index 0000000..e83ef4e
--- /dev/null
+++ b/hCaD_V2/scripts/check-options-occur.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+sed \
+  -e '/^[OLQ[A-Z]*(/!d' \
+  -e 's,^[OLQ[A-Z]*(,,' \
+  -e 's/,.*//' \
+  ../src/options.hpp | \
+while read option
+do
+  grep -q opts.$option ../src/*.hpp ../src/*.cpp && continue
+  echo "option '$option' not found"
+done
diff --git a/hCaD_V2/scripts/colors.sh b/hCaD_V2/scripts/colors.sh
new file mode 100755
index 0000000..d65b919
--- /dev/null
+++ b/hCaD_V2/scripts/colors.sh
@@ -0,0 +1,29 @@
+# Use colors if '<stdin>' is connected to a terminal.
+
+color_echo_options=""
+
+if [ -t 1 ]
+then
+  BAD="\033[1;31m"  # bright red
+  HILITE="\033[32m" # normal green
+  GOOD="\033[1;32m" # bright green
+  HIDE="\033[34m"   # cyan
+  BOLD="\033[1m"    # bold color
+  NORMAL="\033[0m"  # normal color
+
+  if [ x"`echo -e 2>/dev/null`" = x ]
+  then
+    color_echo_options=" -e"
+  fi
+else
+  BAD=""
+  HILITE=""
+  GOOD=""
+  HIDE=""
+  BOLD=""
+  NORMAL=""
+fi
+
+cecho () {
+  echo$color_echo_options $*
+}
diff --git a/hCaD_V2/scripts/extend-solution.sh b/hCaD_V2/scripts/extend-solution.sh
new file mode 100755
index 0000000..44d8e8e
--- /dev/null
+++ b/hCaD_V2/scripts/extend-solution.sh
@@ -0,0 +1,75 @@
+#!/bin/sh
+name=extend-solution.sh
+scriptsdir=`dirname $0`
+colors=$scriptsdir/colors.sh
+if [ -f $colors ]
+then
+  . $colors
+else
+  BAD=""
+  BOLD=""
+  NORMAL=""
+fi
+die () {
+  echo "${BOLD}$name:${NORMAL} ${BAD}error:${NORMAL} $*" 1>&2
+  exit 1
+}
+[ $# -eq 2 ] || \
+die "expected exactly two arguments"
+[ -f $1 ] || \
+die "argument '$1' not a file"
+[ -f $2 ] || \
+die "argument '$2' not a file"
+status="`grep '^s' $1|head -1`"
+case x"$status" in
+  x"s SATISFIABLE") ;;
+  x"s UNSATISFIABLE") echo "s UNSATISFIABLE"; exit 20;;
+  *) die "not valid 's ...' line found in '$1'";;
+esac
+( 
+  grep '^v' $1;
+  awk '{
+    printf "c"
+    for (i = 1; $i; i++)
+      printf " %d", $i
+    printf "\nw";
+    for (i++; $i; i++)
+      printf " %d", $i
+    printf "\n"
+  }' $2
+) | \
+awk '
+function abs (i) { return i < 0 ? -i : i }
+/^v/{
+  for (i = 2; i <= NF; i++) {
+    lit = $i;
+    idx = abs(lit);
+    if (idx) a[idx] = lit;
+  }
+}
+/^c/{
+  satisfied = 0
+  for (i = 2; i <= NF; i++) {
+    lit = $i;
+    idx = abs(lit);
+    tmp = a[idx];
+    if (lit < 0) tmp = -tmp;
+    if (tmp > 0) satisfied = 1;
+  }
+}
+/^w/{
+  if (satisfied) next
+  for (i = 2; i <= NF; i++) {
+    lit = $i;
+    idx = abs(lit);
+    a[idx] = -a[idx];
+  }
+}
+END {
+  print "s SATISFIABLE"
+  for (i in a)
+    print "v", a[i]
+  print "v 0"
+}
+'
+exit 10
diff --git a/hCaD_V2/scripts/generate-cubes.sh b/hCaD_V2/scripts/generate-cubes.sh
new file mode 100755
index 0000000..7b936ac
--- /dev/null
+++ b/hCaD_V2/scripts/generate-cubes.sh
@@ -0,0 +1,37 @@
+#!/bin/sh
+usage () {
+cat <<EOF 2>&1
+usage: generate-cubes.sh [-h] <input> [ <output> [ <march_cu option> ... ] ]
+EOF
+exit 0
+}
+[ "$1" = -h ] && usage
+die () {
+  echo "generate-cubes.sh: error: $*" 1>&2
+  exit 1
+}
+[ $# -lt 1 ] && die "expected DIMACS file argument"
+output=""
+options=""
+[ -f "$1" ] || die "first argument is not a DIMACS file"
+input="$1"
+shift
+while [ $# -gt 0 ]
+do
+  case "$1" in
+    -*) options="$options $1";;
+    *) exec 1>"$1";;
+  esac
+  shift
+done
+prefix=/tmp/generate-cubes-$$
+cleanup () {
+  rm -f $prefix*
+}
+trap "cleanup" 2 11
+cubes=$prefix.cubes
+march_cu $input -o $cubes $options 1>&2 || exit 1
+sed -e 's,^p cnf.*,p inccnf,' $input
+cat $cubes
+cleanup
+exit 0
diff --git a/hCaD_V2/scripts/generate-embedded-options-default-list.sh b/hCaD_V2/scripts/generate-embedded-options-default-list.sh
new file mode 100755
index 0000000..15b44d1
--- /dev/null
+++ b/hCaD_V2/scripts/generate-embedded-options-default-list.sh
@@ -0,0 +1,13 @@
+#!/bin/sh
+cd `dirname $0`
+grep 'OPTION( ' ../src/options.hpp | \
+sed -e 's,^OPTION( ,,' \
+    -e 's/,/ /' \
+    -e 's/,.*//g' | \
+awk '{printf "c --%s=%d\n", $1, $2}' | \
+grep -v 'check' | \
+grep -v 'clim' | \
+grep -v 'dlim' | \
+grep -v 'extend' | \
+grep -v 'learn' | \
+grep -v 'witness'
diff --git a/hCaD_V2/scripts/generate-options-range-list.sh b/hCaD_V2/scripts/generate-options-range-list.sh
new file mode 100755
index 0000000..f5727ca
--- /dev/null
+++ b/hCaD_V2/scripts/generate-options-range-list.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+cd `dirname $0`
+egrep '^(OPTION|BCEOPT|SHROPT)\( ' ../src/options.hpp | \
+grep -v '\<double,' | \
+sed -e 's,^[^(]*(,,' \
+    -e 's/\<int,//' \
+    -e 's/\<bool,//' \
+    -e 's,".*,,' \
+    -e 's/,[^,]*$//' \
+    -e 's,/\*[^\*]*\*/,,' \
+    -e 's/,/ /g' | \
+awk '{printf "%s %d %d %d\n", $1, $2, $3, $4}' | \
+grep -v 'check' | \
+grep -v 'clim' | \
+grep -v 'dlim' | \
+grep -v 'extend' | \
+grep -v 'learn' | \
+grep -v 'witness'
diff --git a/hCaD_V2/scripts/get-git-id.sh b/hCaD_V2/scripts/get-git-id.sh
new file mode 100755
index 0000000..69b1d1f
--- /dev/null
+++ b/hCaD_V2/scripts/get-git-id.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+# print current SHA1 git id which uniquely identifies the source code
+git show 2>/dev/null |awk '{print $2;exit}'
diff --git a/hCaD_V2/scripts/make-build-header.sh b/hCaD_V2/scripts/make-build-header.sh
new file mode 100755
index 0000000..e8f6746
--- /dev/null
+++ b/hCaD_V2/scripts/make-build-header.sh
@@ -0,0 +1,92 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+# Used to generate 'build.hpp', which in turn is used in 'version.cpp' to
+# print compile time options, compiler version, and source code version.
+# If generating 'build.hpp' fails you can still compile 'version.cpp' by
+# using the '-DNBUILD' compile time option.
+
+#--------------------------------------------------------------------------#
+
+die () {
+  echo "make-build-header.sh: error: $*" 1>&2
+  exit 1
+}
+
+warning () {
+  echo "make-build-header.sh: warning: $*" 1>&2
+}
+
+#--------------------------------------------------------------------------#
+
+[ ! -f VERSION -a ! -f ../VERSION ] && \
+die "needs to be called from build sub-directory"
+
+[ -f makefile ] || \
+warning "could not find 'makefile'"
+
+#--------------------------------------------------------------------------#
+# The version.
+#
+VERSION="`cat ../VERSION`"
+if [ x"$VERSION" = x ]
+then
+  warning "could not determine 'VERSION'"
+else
+  echo "#define VERSION \"$VERSION\""
+fi
+
+#--------------------------------------------------------------------------#
+# The unique GIT hash.
+#
+IDENTIFIER="`../scripts/get-git-id.sh`"
+if [ x"$IDENTIFIER" = x ]
+then
+  warning "could not determine 'IDENTIFIER' (git id)"
+else
+  echo "#define IDENTIFIER \"$IDENTIFIER\""
+fi
+
+#--------------------------------------------------------------------------#
+# C++ compiler 'CXX' used in 'makefile'.
+#
+COMPILER="`sed -e '/^CXX=/!d' -e 's,^CXX=,,' makefile 2>/dev/null`"
+case x"$COMPILER" in 
+  x*g++* | x*clang++*)
+    COMPILER="`$COMPILER --version 2>/dev/null|head -1`";;
+  *) COMPILER="";;
+esac
+if [ x"$COMPILER" = x ]
+then
+  warning "could not determine 'COMPILER' ('CXX')"
+else
+  echo "#define COMPILER \"$COMPILER\""
+fi
+
+#--------------------------------------------------------------------------#
+# C++ compiler flags 'CXXFLAGS' used in 'makefile'.
+#
+FLAGS="`sed -e '/^CXXFLAGS=/!d' -e 's,^CXXFLAGS=,,' makefile 2>/dev/null`"
+if [ x"$FLAGS" = x ]
+then
+  warning "could not determine 'FLAGS' ('CXXFLAGS')"
+else
+  echo "#define FLAGS \"$FLAGS\""
+fi
+
+#--------------------------------------------------------------------------#
+# Use time of executing this script at build time.
+#
+LC_TIME="en_US" # Avoid umlaut in 'DATE'.
+export LC_TIME
+# The time and date we compiled the CaDiCaL library.
+DATE="`date 2>/dev/null|sed -e 's,  *, ,g'`"
+OS="`uname -srmn 2>/dev/null`"
+DATE="`echo $DATE $OS|sed -e 's,^ *,,' -e 's, *$,,'`"
+if [ x"$DATE" = x" " ]
+then
+  warning "could not determine 'DATE' (build date and time)"
+else
+  echo "#define DATE \"$DATE\""
+fi
diff --git a/hCaD_V2/scripts/make-src-release.sh b/hCaD_V2/scripts/make-src-release.sh
new file mode 100755
index 0000000..1b546e4
--- /dev/null
+++ b/hCaD_V2/scripts/make-src-release.sh
@@ -0,0 +1,36 @@
+#!/bin/sh
+die () {
+  echo "make-src-release.sh: error: $*" 1>&2
+  exit 1
+}
+cd `dirname $0`/..
+[ -d .git ] || \
+die "does not seem to be under 'git' control ('.git' not found)"
+version="`awk '/define VERSION/{print $4}' src/version.cpp|sed -e 's,",,g'`"
+VERSION="`cat VERSION`"
+[ "$version" = "$VERSION" ] || \
+die "versions '$version' in 'src/version.cpp' and " \
+    "'$VERSION' in 'VERSION' do not match (run 'scripts/update-version.sh')"
+fullgitid="`./scripts/get-git-id.sh`"
+gitid="`echo $fullgitid|sed -e 's,^\(.......\).*,\1,'`"
+branch=`git branch|grep '^\*'|head -1|awk '{print $2}'`
+[ "$branch" = "" ] && die "could not get branch from 'git'"
+name=cadical-${version}-${gitid}
+[ "$branch" = "master" ] || name="$name-$branch"
+dir=/tmp/$name
+tar=/tmp/$name.tar.xz
+rm -rf $dir
+mkdir $dir || exit 1
+git archive $branch | tar -x -C $dir
+cat >$dir/scripts/get-git-id.sh <<EOF
+#!/bin/sh
+echo "$fullgitid"
+EOF
+sed -i -e "s,IDENTIFIER 0$,IDENTIFIER \"$fullgitid\"," $dir/src/version.cpp
+chmod 755 $dir/scripts/*.sh
+cd /tmp
+rm -rf /tmp/$name/.git
+tar cJf $tar $name
+bytes="`ls --block-size=1 -s $tar 2>/dev/null |awk '{print $1}'`"
+echo "generated '$tar' of $bytes bytes"
+rm -rf $dir
diff --git a/hCaD_V2/scripts/normalize-white-space.sh b/hCaD_V2/scripts/normalize-white-space.sh
new file mode 100755
index 0000000..eb513c3
--- /dev/null
+++ b/hCaD_V2/scripts/normalize-white-space.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+cd `dirname $0`/../src
+for i in *.cpp *.hpp
+do
+  cp $i $i~ || exit 1
+  expand $i~ |sed -e 's,  *$,,'|uniq > $i
+  rm -f $i~
+done
diff --git a/hCaD_V2/scripts/prepare-sc2021-submission.sh b/hCaD_V2/scripts/prepare-sc2021-submission.sh
new file mode 100755
index 0000000..143f5ef
--- /dev/null
+++ b/hCaD_V2/scripts/prepare-sc2021-submission.sh
@@ -0,0 +1,52 @@
+#!/bin/sh
+cd `dirname $0`/..
+root=`pwd`
+tmp=/tmp/prepare-cadical-sc2021-submission.log
+VERSION=`cat VERSION`
+rm -f $tmp
+##########################################################################
+cd $root
+./scripts/make-src-release.sh >$tmp || exit 1
+tar=`awk '{print $2}' $tmp |sed -e "s,',,g"`
+##########################################################################
+cd $root
+base=cadical-${VERSION}-starexec
+dir=/tmp/$base
+rm -rf $dir
+mkdir $dir
+mkdir $dir/bin
+mkdir $dir/build
+mkdir $dir/archives
+cp -a $tar $dir/archives
+cat <<EOF >$dir/build/build.sh
+#!/bin/sh
+tar xf ../archives/cadical*
+mv cadical* cadical
+cd cadical
+./configure --competition
+make test
+install -s build/cadical ../../bin/
+EOF
+chmod 755 $dir/build/build.sh
+cat <<EOF >$dir/starexec_build
+#!/bin/sh
+cd build
+exec ./build.sh
+EOF
+chmod 755 $dir/starexec_build
+cat <<EOF >$dir/bin/starexec_run_default
+#!/bin/sh
+exec ./cadical \$1 \$2/proof.out
+EOF
+chmod 755 $dir/bin/starexec_run_default
+description=$dir/starexec_description.txt
+grep '^CaDiCaL' README.md|head -1 >$description
+cat $description
+archive=/tmp/$base.zip
+rm -f $archive
+cd $dir
+zip -r $archive .
+cd /tmp/
+ls -l $archive
+rm -f $tmp
+rm -rf $dir/
diff --git a/hCaD_V2/scripts/run-cadical-and-check-proof.sh b/hCaD_V2/scripts/run-cadical-and-check-proof.sh
new file mode 100755
index 0000000..6ddd6d1
--- /dev/null
+++ b/hCaD_V2/scripts/run-cadical-and-check-proof.sh
@@ -0,0 +1,58 @@
+#!/bin/sh
+scriptsdir=`dirname $0`
+bindir=$scriptsdir/../build
+solver=$bindir/cadical
+solutionchecker=$bindir/precochk
+proofchecker=$bindir/drat-trim
+name=run-cadical-and-check-proof.sh
+colors=$scriptsdir/colors.sh
+if [ -f $colors ]
+then
+  . $colors
+else
+  BAD=""
+  BOLD=""
+  HIDE=""
+  NORMAL=""
+fi
+die () {
+  echo "$name: error: $*" 1>&2
+  exit 1
+}
+msg () {
+  echo "${HIDE}c [$name] $*${NORMAL}"
+}
+[ $# -eq 1 ] || \
+die "expected exactly one argument"
+msg "input '$1'"
+[ -f $solver ] || \
+die "can not find '$solver' (build solver first)"
+msg "found '$solver'"
+[ -f $solutionchecker ] || \
+die "can not find '$solutionchecker' (run cnf tests to compile it first)"
+msg "found '$solutionchecker'"
+[ -f $proofchecker ] || \
+die "can not find '$proofchecker' (run cnf tests to compile it first)"
+msg "found '$proofchecker'"
+prefix=/tmp/run-cadical-and-check-proof-$$
+trap "rm -f $prefix*" 2 9 15
+msg "$solver $1 $prefix.proof > $prefix.log"
+$solver $1 $prefix.proof > $prefix.log
+res=$?
+msg "solver exit code '$res'"
+msg "cat $prefix.log"
+cat $prefix.log
+case $res in
+  10) 
+    msg "$solutionchecker $1 $prefix.log"
+    $solutionchecker $1 $prefix.log || exit 1
+    ;;
+  20)
+    msg "$proofchecker $1 $prefix.proof"
+    $proofchecker $1 $prefix.proof || exit 1
+    ;;
+esac
+msg "rm -f $prefix*"
+rm -f $prefix*
+msg "exit $res"
+exit $res
diff --git a/hCaD_V2/scripts/run-simplifier-and-extend-solution.sh b/hCaD_V2/scripts/run-simplifier-and-extend-solution.sh
new file mode 100755
index 0000000..945f22f
--- /dev/null
+++ b/hCaD_V2/scripts/run-simplifier-and-extend-solution.sh
@@ -0,0 +1,84 @@
+#!/bin/sh
+scriptsdir=`dirname $0`
+bindir=$scriptsdir/../build
+solver=$bindir/cadical
+colors=$scriptsdir/colors.sh
+extend=$scriptsdir/extend-solution.sh
+name=run-simplifier-and-extend-solution.sh
+if [ -f $colors ]
+then
+  . $colors
+else
+  BAD=""
+  BOLD=""
+  HIDE=""
+  NORMAL=""
+fi
+die () {
+  echo "${BOLD}$name:${NORMAL} ${BAD}error:${NORMAL} $*" 1>&2
+  exit 1
+}
+msg () {
+  echo "${HIDE}c [$name] $*${NORMAL}"
+}
+input=""
+options=""
+while [ $# -gt 0 ]
+do
+  case $1 in
+    -t) options="$1 $2"; shift;;
+    *)
+      if [ -f $1 ]
+      then
+        [ "$input" ] && die "too many inputs"
+        input="$1"
+      else
+	die "invalid option '$1'"
+      fi
+      ;;
+  esac
+  shift
+done
+msg "input '$input'"
+msg "options '$options'"
+[ "$input" ] || die "expected at least one input argument"
+[ -f $solver ] || \
+die "can not find '$solver' (build solver first)"
+msg "found '$solver'"
+[ -f $extend ] || \
+die "can not find '$extend'"
+prefix=/tmp/run-simplifier-and-extend-solution-$$
+trap "rm -f $prefix*" 2 9 15
+out=$prefix.out
+ext=$prefix.ext
+log=$prefix.log
+msg "$solver $options -n -O1 -c 0 -o $out -e $ext $input > $log"
+$solver $options -n -O1 -c 0 -o $out -e $ext $input > $log
+res=$?
+msg "simplifier exit code '$res'"
+msg "sed -e 's,^[vs],c,' -e 's,^c,c [simplifier],' $log"
+sed -e 's,^[vs],c,' -e 's,^c,c [simplifier],' $log
+msg "$solver $options $out > $log"
+$solver $options $out > $log
+res=$?
+msg "solver exit code '$res'"
+msg "sed -e 's,^[vs],c,' -e 's,^c,c [solver],' $log"
+sed -e 's,^[vs],c,' -e 's,^c,c [solver],' $log
+case $res in
+  0|10|20) ;;
+  *) die "unexpected solver exit code '$res'";;
+esac
+if [ $res = 10 ]
+then
+  msg "$extend $log $ext"
+  $extend $log $ext
+  res=$?
+  msg "extender exit code $res"
+elif [ $res = 20 ]
+then
+  echo "s UNSATISFIABLE"
+fi
+msg "rm -f $prefix*"
+rm -f $prefix*
+msg "exit $res"
+exit $res
diff --git a/hCaD_V2/scripts/update-example-in-cadical-header-file.sh b/hCaD_V2/scripts/update-example-in-cadical-header-file.sh
new file mode 100755
index 0000000..b447b52
--- /dev/null
+++ b/hCaD_V2/scripts/update-example-in-cadical-header-file.sh
@@ -0,0 +1,28 @@
+#!/bin/sh
+
+echo `dirname $0`
+cd `dirname $0`
+
+pwd
+
+. ./colors.sh
+
+new=/tmp/cadical.hpp
+old=../src/cadical.hpp
+example=../test/api/example.cpp
+
+rm -f $new
+sed -e '/solver = new CaDiCaL::Solver/,$d' $old >> $new
+sed -e '/solver = new CaDiCaL::Solver/,/delete solver/!d' $example | \
+expand | sed -e 's,^,//  ,' >> $new
+sed -e '1,/delete solver/d' $old >> $new
+
+echo "${HILITE}diff $old $new${NORMAL}"
+if diff $old $new
+then
+  echo "${GOOD}no need to update '$old'${NORMAL}"
+else
+  echo "${BAD}cp $new $old${NORMAL}"
+  cp $new $old
+fi
+rm -f $new
diff --git a/hCaD_V2/scripts/update-version.sh b/hCaD_V2/scripts/update-version.sh
new file mode 100755
index 0000000..58641ac
--- /dev/null
+++ b/hCaD_V2/scripts/update-version.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+cd `dirname $0`
+NEW="`cat ../VERSION`"
+OLD="`awk '/define VERSION/{print \$4}' ../src/version.cpp|sed -e 's,\",,g'`"
+if [ x"$OLD" = x"$NEW" ]
+then
+  echo "same version '$NEW' in 'VERSION' and '../src/version.cpp'"
+else
+  echo "found new version '$NEW' in '../VERSION'"
+  echo "updating old version '$OLD' in '../src/version.cpp'"
+  sed -i -e '/define VERSION/s,".*",'\""$NEW"\", ../src/version.cpp
+fi
diff --git a/hCaD_V2/src/README.md b/hCaD_V2/src/README.md
new file mode 100644
index 0000000..f17395f
--- /dev/null
+++ b/hCaD_V2/src/README.md
@@ -0,0 +1,12 @@
+This is the source code of the library `libcadical.a` with header
+`cadical.hpp`, the stand-alone solver `cadical` (in `cadical.cpp`) and the
+model based tester `mobical` (in `mobical.app`).
+
+The `configure` script and link to the `makefile` in the root directory
+can be used from within the `src` sub-directory too and then will just work
+as if used from the root directory.  For instance
+
+    ./configure && make test
+
+will configure and build in `../build` the default (optimizing)
+configuration and if successful then run the test suite.
diff --git a/hCaD_V2/src/analyze.cpp b/hCaD_V2/src/analyze.cpp
new file mode 100644
index 0000000..5f3f643
--- /dev/null
+++ b/hCaD_V2/src/analyze.cpp
@@ -0,0 +1,830 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Code for conflict analysis, i.e., to generate the first UIP clause.  The
+// main function is 'analyze' below.  It further uses 'minimize' to minimize
+// the first UIP clause, which is in 'minimize.cpp'.  An important side
+// effect of conflict analysis is to update the decision queue by bumping
+// variables.  Similarly analyzed clauses are bumped to mark them as active.
+
+/*------------------------------------------------------------------------*/
+
+void Internal::learn_empty_clause () {
+  assert (!unsat);
+  LOG ("learned empty clause");
+  external->check_learned_empty_clause ();
+  if (proof) proof->add_derived_empty_clause ();
+  unsat = true;
+}
+
+void Internal::learn_unit_clause (int lit) {
+  LOG ("learned unit clause %d", lit);
+  external->check_learned_unit_clause (lit);
+  if (proof) proof->add_derived_unit_clause (lit);
+  mark_fixed (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Move bumped variables to the front of the (VMTF) decision queue.  The
+// 'bumped' time stamp is updated accordingly.  It is used to determine
+// whether the 'queue.assigned' pointer has to be moved in 'unassign'.
+
+void Internal::bump_queue (int lit) {
+  assert (opts.bump);
+  const int idx = vidx (lit);
+  if (!links[idx].next) return;
+  queue.dequeue (links, idx);
+  queue.enqueue (links, idx);
+  assert (stats.bumped != INT64_MAX);
+  btab[idx] = ++stats.bumped;
+  LOG ("moved to front variable %d and bumped to %" PRId64 "", idx, btab[idx]);
+  if (!vals[idx]) update_queue_unassigned (idx);
+}
+
+/*------------------------------------------------------------------------*/
+
+// It would be better to use 'isinf' but there are some historical issues
+// with this function.  On some platforms it is a macro and even for C++ it
+// changed the scope (in pre 5.0 gcc) from '::isinf' to 'std::isinf'.  I do
+// not want to worry about these strange incompatibilities and thus use the
+// same trick as in older solvers (since the MiniSAT team invented EVSIDS)
+// and simply put a hard limit here.  It is less elegant but easy to port.
+
+static inline bool evsids_limit_hit (double score) {
+  assert (sizeof (score) == 8); // assume IEEE 754 64-bit double
+  return score > 1e150;         // MAX_DOUBLE is around 1.8e308
+}
+
+/*------------------------------------------------------------------------*/
+
+// Classical exponential VSIDS as pioneered by MiniSAT.
+
+void Internal::rescale_variable_scores () {
+  stats.rescored++;
+  double divider = score_inc;
+  for (auto idx : vars) {
+    const double tmp = stab[idx];
+    if (tmp > divider) divider = tmp;
+  }
+  PHASE ("rescore", stats.rescored,
+    "rescoring %d variable scores by 1/%g", max_var, divider);
+  assert (divider > 0);
+  double factor = 1.0 / divider;
+  for (auto idx : vars)
+    stab[idx] *= factor;
+  score_inc *= factor;
+  PHASE ("rescore", stats.rescored,
+    "new score increment %g after %" PRId64 " conflicts",
+    score_inc, stats.conflicts);
+}
+
+void Internal::bump_variable_score (int lit) {
+  assert (opts.bump);
+  int idx = vidx (lit);
+  double old_score = score (idx);
+  assert (!evsids_limit_hit (old_score));
+  double new_score = old_score + score_inc;
+  if (evsids_limit_hit (new_score)) {
+    LOG ("bumping %g score of %d hits EVSIDS score limit", old_score, idx);
+    rescale_variable_scores ();
+    old_score = score (idx);
+    assert (!evsids_limit_hit (old_score));
+    new_score = old_score + score_inc;
+  }
+  assert (!evsids_limit_hit (new_score));
+  LOG ("new %g score of %d", new_score, idx);
+  score (idx) = new_score;
+  if (scores.contains (idx)) scores.update (idx);
+}
+
+// Important variables recently used in conflict analysis are 'bumped',
+
+void Internal::bump_variable (int lit) {
+  if (use_scores ()) bump_variable_score (lit);
+  else bump_queue (lit);
+}
+
+// After every conflict the variable score increment is increased by a
+// factor (if we are currently using scores).
+
+void Internal::bump_variable_score_inc () {
+  assert (use_scores ());
+  assert (!evsids_limit_hit (score_inc));
+  double f = 1e3/opts.scorefactor;
+  double new_score_inc = score_inc * f;
+  if (evsids_limit_hit (new_score_inc)) {
+    LOG ("bumping %g increment by %g hits EVSIDS score limit", score_inc, f);
+    rescale_variable_scores ();
+    new_score_inc = score_inc * f;
+  }
+  assert (!evsids_limit_hit (new_score_inc));
+  LOG ("bumped score increment from %g to %g with factor %g",
+    score_inc, new_score_inc, f);
+  score_inc = new_score_inc;
+}
+
+
+void Internal::pol_dec_act() {
+    
+  double f = 1e3/opts.scorefactor,
+     nps_i = pol_sc_inc * f;
+  if (nps_i > 1e150) {
+    rescale_pol_scs ();
+    nps_i = pol_sc_inc * f;
+  }
+  pol_sc_inc = nps_i;
+}
+
+void Internal::rescale_pol_scs () {
+  double f, m = pol_sc_inc;
+  for (auto l : lits) {
+    const double tmp = phases.act[vlit(l)];
+    if (tmp > m) m = tmp;
+  }
+
+  f = 1.0 / m;
+  for (auto l : lits)
+    phases.act[vlit(l)] *= f;
+  pol_sc_inc *= f;
+}
+
+void Internal::bump_pol_sc (int lt) {
+  int l = vlit (lt);  
+  double os = phases.act[l],
+         ns = os + pol_sc_inc;
+  if (ns > 1e150) {
+    rescale_pol_scs ();
+    os = phases.act[l];
+    ns = os + pol_sc_inc;
+  }
+  phases.act[l] = ns;
+}
+/*------------------------------------------------------------------------*/
+
+struct analyze_bumped_rank {
+  Internal * internal;
+  analyze_bumped_rank (Internal * i) : internal (i) { }
+  typedef uint64_t Type;
+  Type operator () (const int & a) const {
+    return internal->bumped (a);
+  }
+};
+
+struct analyze_bumped_smaller {
+  Internal * internal;
+  analyze_bumped_smaller (Internal * i) : internal (i) { }
+  bool operator () (const int & a, const int & b) const {
+    const auto s = analyze_bumped_rank (internal) (a);
+    const auto t = analyze_bumped_rank (internal) (b);
+    return s < t;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+void Internal::bump_variables () {
+
+  assert (opts.bump);
+
+  START (bump);
+
+  if (opts.bumpreason) bump_also_all_reason_literals ();
+
+  if (!use_scores ()) {
+
+    // Variables are bumped in the order they are in the current decision
+    // queue.  This maintains relative order between bumped variables in
+    // the queue and seems to work best.  We also experimented with
+    // focusing on variables of the last decision level, but results were
+    // mixed.
+
+    MSORT (opts.radixsortlim,
+      analyzed.begin (), analyzed.end (),
+      analyze_bumped_rank (this), analyze_bumped_smaller (this));
+  }
+
+  for (const auto & lit : analyzed)
+    bump_variable (lit);
+
+  if (use_scores ()) bump_variable_score_inc ();
+
+  STOP (bump);
+}
+
+/*------------------------------------------------------------------------*/
+
+// We use the glue time stamp table 'gtab' for fast glue computation.
+
+int Internal::recompute_glue (Clause * c) {
+  int res = 0;
+  const int64_t stamp = ++stats.recomputed;
+  for (const auto & lit : *c) {
+    int level = var (lit).level;
+    assert (gtab[level] <= stamp);
+    if (gtab[level] == stamp) continue;
+    gtab[level] = stamp;
+    res++;
+  }
+  return res;
+}
+
+// Clauses resolved since the last reduction are marked as 'used', their
+// glue is recomputed and they are promoted if the glue shrinks.  Note that
+// promotion from 'tier3' to 'tier2' will set 'used' to '2'.
+
+inline void Internal::bump_clause (Clause * c) {
+  LOG (c, "bumping");
+  unsigned used = c->used;
+  c->used = 1;
+  if (c->keep) return;
+  if (c->hyper) return;
+  if (!c->redundant) return;
+  int new_glue = recompute_glue (c);
+  if (new_glue < c->glue) promote_clause (c, new_glue);
+  else if (used && c->glue <= opts.reducetier2glue) c->used = 2;
+}
+
+/*------------------------------------------------------------------------*/
+
+// During conflict analysis literals not seen yet either become part of the
+// first unique implication point (UIP) clause (if on lower decision level),
+// are dropped (if fixed), or are resolved away (if on the current decision
+// level and different from the first UIP).  At the same time we update the
+// number of seen literals on a decision level.  This helps conflict clause
+// minimization.  The number of seen levels is the glucose level (also
+// called 'glue', or 'LBD').
+
+inline void
+Internal::analyze_literal (int lit, int & open) {
+  assert (lit);
+  Flags & f = flags (lit);
+  if (f.seen) return;
+  Var & v = var (lit);
+  if (!v.level) return;
+  assert (val (lit) < 0);
+  assert (v.level <= level);
+  if (v.level < level) clause.push_back (lit);
+  Level & l = control[v.level];
+  if (!l.seen.count++) {
+    LOG ("found new level %d contributing to conflict", v.level);
+    levels.push_back (v.level);
+  }
+  if (v.trail < l.seen.trail) l.seen.trail = v.trail;
+  f.seen = true;
+  analyzed.push_back (lit);
+  LOG ("analyzed literal %d assigned at level %d", lit, v.level);
+  if (v.level == level) open++;
+}
+
+inline void
+Internal::analyze_reason (int lit, Clause * reason, int & open) {
+  assert (reason);
+  bump_clause (reason);
+  for (const auto & other : *reason)
+    if (other != lit)
+      analyze_literal (other, open);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is an idea which was implicit in MapleCOMSPS 2016 for 'limit = 1'.
+// See also the paragraph on 'bumping reason side literals' in their SAT'16
+// paper [LiangGaneshPoupartCzarnecki-SAT'16].  Reason side bumping was
+// performed exactly when 'LRB' based decision heuristics was used, which in
+// the original version was enabled after 10000 conflicts until a time limit
+// of 2500 seconds was reached (half of the competition time limit).  The
+// Maple / Glucose / MiniSAT evolution winning the SAT race in 2019 made
+// the schedule of reason side bumping deterministic, i.e., avoiding a time
+// limit, by switching between 'LRB' and 'VSIDS' in an interval of initially
+// 30 million propagations, which then is increased geometrically by 10%.
+
+inline bool Internal::bump_also_reason_literal (int lit) {
+  assert (lit);
+  assert (val (lit) < 0);
+  Flags & f = flags (lit);
+  if (f.seen) return false;
+  const Var & v = var (lit);
+  if (!v.level) return false;
+  f.seen = true;
+  analyzed.push_back (lit);
+  LOG ("bumping also reason literal %d assigned at level %d", lit, v.level);
+  return true;
+}
+
+// We experimented with deeper reason bumping without much success though.
+
+inline void Internal::bump_also_reason_literals (int lit, int limit) {
+  assert (lit);
+  assert (limit > 0);
+  const Var & v = var (lit);
+  assert (val (lit));
+  if (!v.level) return;
+  Clause * reason = v.reason;
+  if (!reason) return;
+  for (const auto & other : *reason) {
+    if (other == lit)  continue;
+    if (!bump_also_reason_literal (other)) continue;
+    if (limit < 2) continue;
+    bump_also_reason_literals (-other, limit-1);
+  }
+}
+
+inline void Internal::bump_also_all_reason_literals () {
+  assert (opts.bumpreason);
+  assert (opts.bumpreasondepth > 0);
+  LOG ("bumping reasons up to depth %d", opts.bumpreasondepth);
+  for (const auto & lit : clause)
+    bump_also_reason_literals (-lit, opts.bumpreasondepth + stable);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::clear_analyzed_literals () {
+  LOG ("clearing %zd analyzed literals", analyzed.size ());
+  for (const auto & lit : analyzed) {
+    Flags & f = flags (lit);
+    assert (f.seen);
+    f.seen = false;
+    assert (!f.keep);
+    assert (!f.poison);
+    assert (!f.removable);
+  }
+  analyzed.clear ();
+}
+
+void Internal::clear_analyzed_levels () {
+  LOG ("clearing %zd analyzed levels", levels.size ());
+  for (const auto & l : levels)
+    if (l < (int) control.size ())
+      control[l].reset ();
+  levels.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Smaller level and trail.  Comparing literals on their level is necessary
+// for chronological backtracking, since trail order might in this case not
+// respect level order.
+
+struct analyze_trail_negative_rank {
+  Internal * internal;
+  analyze_trail_negative_rank (Internal * s) : internal (s) { }
+  typedef uint64_t Type;
+  Type operator () (int a) {
+    Var & v = internal->var (a);
+    uint64_t res = v.level;
+    res <<= 32;
+    res |= v.trail;
+    return ~res;
+  }
+};
+
+struct analyze_trail_larger {
+  Internal * internal;
+  analyze_trail_larger (Internal * s) : internal (s) { }
+  bool operator () (const int & a, const int & b) const {
+    return
+      analyze_trail_negative_rank (internal) (a) <
+      analyze_trail_negative_rank (internal) (b);
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Generate new driving clause and compute jump level.
+
+Clause * Internal::new_driving_clause (const int glue, int & jump) {
+
+  const size_t size = clause.size ();
+  Clause * res;
+
+  if (!size) {
+
+    jump = 0;
+    res = 0;
+
+  } else if (size == 1) {
+
+    iterating = true;
+    jump = 0;
+    res = 0;
+
+  } else {
+
+    assert (clause.size () > 1);
+
+    // We have to get the last assigned literals into the watch position.
+    // Sorting all literals with respect to reverse assignment order is
+    // overkill but seems to get slightly faster run-time.  For 'minimize'
+    // we sort the literals too heuristically along the trail order (so in
+    // the opposite order) with the hope to hit the recursion limit less
+    // frequently.  Thus sorting effort is doubled here.
+    //
+    MSORT (opts.radixsortlim,
+           clause.begin (), clause.end (),
+           analyze_trail_negative_rank (this), analyze_trail_larger (this));
+
+    jump = var (clause[1]).level;
+    res = new_learned_redundant_clause (glue);
+    res->used = 1 + (glue <= opts.reducetier2glue);
+  }
+
+  LOG ("jump level %d", jump);
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// If chronological backtracking is enabled we need to find the actual
+// conflict level and then potentially can also reuse the conflict clause
+// as driving clause instead of deriving a redundant new driving clause
+// (forcing 'forced') if the number 'count' of literals in conflict assigned
+// at the conflict level is exactly one.
+
+inline int Internal::find_conflict_level (int & forced) {
+
+  assert (conflict);
+  assert (opts.chrono);
+
+  int res = 0, count = 0;
+
+  forced = 0;
+
+  for (const auto & lit : *conflict) {
+    const int tmp = var (lit).level;
+    if (tmp > res) {
+      res = tmp;
+      forced = lit;
+      count = 1;
+    } else if (tmp == res) {
+      count++;
+      if (res == level && count > 1)
+        break;
+    }
+  }
+
+  LOG ("%d literals on actual conflict level %d", count, res);
+
+  const int size = conflict->size;
+  int * lits = conflict->literals;
+
+  // Move the two highest level literals to the front.
+  //
+  for (int i = 0; i < 2; i++) {
+
+    const int lit = lits[i];
+
+    int highest_position = i;
+    int highest_literal = lit;
+    int highest_level = var (highest_literal).level;
+
+    for (int j = i + 1; j < size; j++) {
+      const int other = lits[j];
+      const int tmp = var (other).level;
+      if (highest_level >= tmp) continue;
+      highest_literal = other;
+      highest_position = j;
+      highest_level = tmp;
+      if (highest_level == res) break;
+    }
+
+    // No unwatched higher assignment level literal.
+    //
+    if (highest_position == i) continue;
+
+    if (highest_position > 1)
+      {
+        LOG (conflict, "unwatch %d in", lit);
+        remove_watch (watches (lit), conflict);
+      }
+
+    lits[highest_position] = lit;
+    lits[i] = highest_literal;
+
+    if (highest_position > 1)
+      watch_literal (highest_literal, lits[!i], conflict);
+  }
+
+  // Only if the number of highest level literals in the conflict is one
+  // then we can reuse the conflict clause as driving clause for 'forced'.
+  //
+  if (count != 1) forced = 0;
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline int Internal::determine_actual_backtrack_level (int jump) {
+
+  int res;
+
+  assert (level > jump);
+
+  if (!opts.chrono) {
+    res = jump;
+    LOG ("chronological backtracking disabled using jump level %d", res);
+  } else if (opts.chronoalways) {
+    stats.chrono++;
+    res = level - 1;
+    LOG ("forced chronological backtracking to level %d", res);
+  } else if (jump >= level - 1) {
+    res = jump;
+    LOG ("jump level identical to chronological backtrack level %d", res);
+  } else if ((size_t) jump < assumptions.size ()) {
+    res = jump;
+    LOG ("using jump level %d since it is lower than assumption level %zd",
+      res, assumptions.size ());
+  } else if (level - jump > opts.chronolevelim) {
+    stats.chrono++;
+    res = level - 1;
+    LOG ("back-jumping over %d > %d levels prohibited"
+      "thus backtracking chronologically to level %d",
+      level - jump, opts.chronolevelim, res);
+  } else if (opts.chronoreusetrail) {
+
+    int best_idx = 0, best_pos = 0;
+
+    if (use_scores ()) {
+      for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
+        const int idx = abs (trail[i]);
+        if (best_idx && !score_smaller (this) (best_idx, idx)) continue;
+        best_idx = idx;
+        best_pos = i;
+      }
+      LOG ("best variable score %g", score (best_idx));
+    } else {
+      for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
+        const int idx = abs (trail[i]);
+        if (best_idx && bumped (best_idx) >= bumped (idx)) continue;
+        best_idx = idx;
+        best_pos = i;
+      }
+      LOG ("best variable bumped %" PRId64 "", bumped (best_idx));
+    }
+    assert (best_idx);
+    LOG ("best variable %d at trail position %d", best_idx, best_pos);
+
+    // Now find the frame and decision level in the control stack of that
+    // best variable index.  Note that, as in 'reuse_trail', the frame
+    // 'control[i]' for decision level 'i' contains the trail before that
+    // decision level, i.e., the decision 'control[i].decision' sits at
+    // 'control[i].trail' in the trail and we thus have to check the level
+    // of the control frame one higher than at the result level.
+    //
+    res = jump;
+    while (res < level-1 && control[res+1].trail <= best_pos)
+      res++;
+
+    if (res == jump)
+      LOG ("default non-chronological back-jumping to level %d", res);
+    else {
+      stats.chrono++;
+      LOG ("chronological backtracking to level %d to reuse trail", res);
+    }
+
+  } else {
+    res = jump;
+    LOG ("non-chronological back-jumping to level %d", res);
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::eagerly_subsume_recently_learned_clauses (Clause * c) {
+  assert (opts.eagersubsume);
+  LOG (c, "trying eager subsumption with");
+  mark (c);
+  int64_t lim = stats.eagertried + opts.eagersubsumelim;
+  const auto begin = clauses.begin ();
+  auto it = clauses.end ();
+#ifdef LOGGING
+  int64_t before = stats.eagersub;
+#endif
+  while (it != begin && stats.eagertried++ <= lim) {
+    Clause * d =  *--it;
+    if (c == d) continue;
+    if (d->garbage) continue;
+    if (!d->redundant) continue;
+    int needed = c->size;
+    for (auto & lit : *d) {
+      if (marked (lit) <= 0) continue;
+      if (!--needed) break;
+    }
+    if (needed) continue;
+    LOG (d, "eager subsumed");
+    stats.eagersub++;
+    stats.subsumed++;
+    mark_garbage (d);
+  }
+  unmark (c);
+#ifdef LOGGING
+  uint64_t subsumed = stats.eagersub - before;
+  if (subsumed) LOG ("eagerly subsumed %" PRIu64 " clauses", subsumed);
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the main conflict analysis routine.  It assumes that a conflict
+// was found.  Then we derive the 1st UIP clause, optionally minimize it,
+// add it as learned clause, and then uses the clause for conflict directed
+// back-jumping and flipping the 1st UIP literal.  In combination with
+// chronological backtracking (see discussion above) the algorithm becomes
+// slightly more involved.
+
+void Internal::analyze () {
+
+  START (analyze);
+
+  assert (conflict);
+
+  // First update moving averages of trail height at conflict.
+  //
+  UPDATE_AVERAGE (averages.current.trail.fast, trail.size ());
+  UPDATE_AVERAGE (averages.current.trail.slow, trail.size ());
+
+  /*----------------------------------------------------------------------*/
+
+  if (opts.chrono) {
+
+    int forced;
+
+    const int conflict_level = find_conflict_level (forced);
+
+    // In principle we can perform conflict analysis as in non-chronological
+    // backtracking except if there is only one literal with the maximum
+    // assignment level in the clause.  Then standard conflict analysis is
+    // unnecessary and we can use the conflict as a driving clause.  In the
+    // pseudo code of the SAT'18 paper on chronological backtracking this
+    // corresponds to the situation handled in line 4-6 in Alg. 1, except
+    // that the pseudo code in the paper only backtracks while we eagerly
+    // assign the single literal on the highest decision level.
+
+    if (forced) {
+
+      assert (forced);
+      assert (conflict_level > 0);
+      LOG ("single highest level literal %d", forced);
+
+      // The pseudo code in the SAT'18 paper actually backtracks to the
+      // 'second highest decision' level, while their code backtracks
+      // to 'conflict_level-1', which is more in the spirit of chronological
+      // backtracking anyhow and thus we also do the latter.
+      //
+      backtrack (conflict_level - 1);
+
+      LOG ("forcing %d", forced);
+      search_assign_driving (forced, conflict);
+
+      conflict = 0;
+      STOP (analyze);
+      return;
+    }
+
+    // Backtracking to the conflict level is in the pseudo code in the
+    // SAT'18 chronological backtracking paper, but not in their actual
+    // implementation.  In principle we do not need to backtrack here.
+    // However, as a side effect of backtracking to the conflict level we
+    // set 'level' to the conflict level which then allows us to reuse the
+    // old 'analyze' code as is.  The alternative (which we also tried but
+    // then abandoned) is to use 'conflict_level' instead of 'level' in the
+    // analysis, which however requires to pass it to the 'analyze_reason'
+    // and 'analyze_literal' functions.
+    //
+    backtrack (conflict_level);
+  }
+
+  // Actual conflict on root level, thus formula unsatisfiable.
+  //
+  if (!level) {
+    learn_empty_clause ();
+    if (external->learner) external->export_learned_empty_clause ();
+    STOP (analyze);
+    return;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  // First derive the 1st UIP clause by going over literals assigned on the
+  // current decision level.  Literals in the conflict are marked as 'seen'
+  // as well as all literals in reason clauses of already 'seen' literals on
+  // the current decision level.  Thus the outer loop starts with the
+  // conflict clause as 'reason' and then uses the 'reason' of the next
+  // seen literal on the trail assigned on the current decision level.
+  // During this process maintain the number 'open' of seen literals on the
+  // current decision level with not yet processed 'reason'.  As soon 'open'
+  // drops to one, we have found the first unique implication point.  This
+  // is sound because the topological order in which literals are processed
+  // follows the assignment order and a more complex algorithm to find
+  // articulation points is not necessary.
+  //
+  Clause * reason = conflict;
+  LOG (reason, "analyzing conflict");
+
+  assert (clause.empty ());
+
+  int i = trail.size ();        // Start at end-of-trail.
+  int open = 0;                 // Seen but not processed on this level.
+  int uip = 0;                  // The first UIP literal.
+
+  for (;;) {
+    analyze_reason (uip, reason, open);
+    uip = 0;
+    while (!uip) {
+      assert (i > 0);
+      const int lit = trail[--i];
+      if (!flags (lit).seen) continue;
+      if (var (lit).level == level) uip = lit;
+    }
+    if (!--open) break;
+    reason = var (uip).reason;
+    LOG (reason, "analyzing %d reason", uip);
+  }
+  LOG ("first UIP %d", uip);
+  clause.push_back (-uip);
+
+  // Update glue and learned (1st UIP literals) statistics.
+  //
+  int size = (int) clause.size ();
+  const int glue = (int) levels.size () - 1;
+  LOG (clause, "1st UIP size %d and glue %d clause", size, glue);
+  UPDATE_AVERAGE (averages.current.glue.fast, glue);
+  UPDATE_AVERAGE (averages.current.glue.slow, glue);
+  stats.learned.literals += size;
+  stats.learned.clauses++;
+  assert (glue < size);
+
+
+  // Minimize the 1st UIP clause as pioneered by Niklas Soerensson in
+  // MiniSAT and described in our joint SAT'09 paper.
+  //
+  if (size > 1) {
+    if (opts.shrink)
+      shrink_and_minimize_clause();
+    else if (opts.minimize)
+      minimize_clause();
+
+    size = (int) clause.size ();
+
+    // Update decision heuristics.
+    //
+    if (opts.bump)
+      bump_variables();
+    
+    if(opts.psids) pol_dec_act();
+
+    if (external->learner) external->export_learned_large_clause (clause);
+  } else if (external->learner)
+    external->export_learned_unit_clause(-uip);
+
+  // Update actual size statistics.
+  //
+  stats.units    += (size == 1);
+  stats.binaries += (size == 2);
+  UPDATE_AVERAGE (averages.current.size, size);
+
+  // Determine back-jump level, learn driving clause, backtrack and assign
+  // flipped 1st UIP literal.
+  //
+  int jump;
+  Clause * driving_clause = new_driving_clause (glue, jump);
+  UPDATE_AVERAGE (averages.current.jump, jump);
+
+  int new_level = determine_actual_backtrack_level (jump);;
+  UPDATE_AVERAGE (averages.current.level, new_level);
+  backtrack (new_level);
+
+  if (uip) search_assign_driving (-uip, driving_clause);
+  else learn_empty_clause ();
+
+  if (stable) reluctant.tick (); // Reluctant has its own 'conflict' counter.
+
+  // Clean up.
+  //
+  clear_analyzed_literals ();
+  clear_analyzed_levels ();
+  clause.clear ();
+  conflict = 0;
+
+  STOP (analyze);
+
+  if (driving_clause && opts.eagersubsume)
+    eagerly_subsume_recently_learned_clauses (driving_clause);
+}
+
+// We wait reporting a learned unit until propagation of that unit is
+// completed.  Otherwise the 'i' report gives the number of remaining
+// variables before propagating the unit (and hides the actual remaining
+// variables after propagating it).
+
+void Internal::iterate () { iterating = false; report ('i'); }
+
+}
diff --git a/hCaD_V2/src/arena.cpp b/hCaD_V2/src/arena.cpp
new file mode 100644
index 0000000..61123ec
--- /dev/null
+++ b/hCaD_V2/src/arena.cpp
@@ -0,0 +1,30 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+Arena::Arena (Internal * i) {
+  memset (this, 0, sizeof *this);
+  internal = i;
+}
+
+Arena::~Arena () {
+  delete [] from.start;
+  delete [] to.start;
+}
+
+void Arena::prepare (size_t bytes) {
+  LOG ("preparing 'to' space of arena with %zd bytes", bytes);
+  assert (!to.start);
+  to.top = to.start = new char[bytes];
+  to.end = to.start + bytes;
+}
+
+void Arena::swap () {
+  delete [] from.start;
+  LOG ("delete 'from' space of arena with %zd bytes",
+    (size_t) (from.end - from.start));
+  from = to;
+  to.start = to.top = to.end = 0;
+}
+
+}
diff --git a/hCaD_V2/src/arena.hpp b/hCaD_V2/src/arena.hpp
new file mode 100644
index 0000000..1a41ade
--- /dev/null
+++ b/hCaD_V2/src/arena.hpp
@@ -0,0 +1,103 @@
+#ifndef _arena_hpp_INCLUDED
+#define _arena_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+// This memory allocation arena provides fixed size pre-allocated memory for
+// the moving garbage collector 'copy_non_garbage_clauses' in 'collect.cpp'
+// to hold clauses which should survive garbage collection.
+
+// The advantage of using a pre-allocated arena is that the allocation order
+// of the clauses can be adapted in such a way that clauses watched by the
+// same literal are allocated consecutively.  This improves locality during
+// propagation and thus is more cache friendly. A similar technique is
+// implemented in MiniSAT and Glucose and gives substantial speed-up in
+// propagations per second even though it might even almost double peek
+// memory usage.  Note that in MiniSAT this arena is actually required for
+// MiniSAT to be able to use 32 bit clauses references instead of 64 bit
+// pointers.  This would restrict the maximum number of clauses and thus is
+// a restriction we do not want to use anymore.
+
+// New learned clauses are allocated in CaDiCaL outside of this arena and
+// moved to the arena during garbage collection.  The additional 'to' space
+// required for such a moving garbage collector is only allocated for those
+// clauses surviving garbage collection, which usually needs much less
+// memory than all clauses.  The net effect is that in our implementation
+// the moving garbage collector using this arena only needs roughly 50% more
+// memory than allocating the clauses directly.  Both implementations can be
+// compared by varying the 'opts.arenatype' option (which also controls the
+// allocation order of clauses during moving them).
+
+// The standard sequence of using the arena is as follows:
+//
+//   Arena arena;
+//   ...
+//   arena.prepare (bytes);
+//   q1 = arena.copy (p1, bytes1);
+//   ...
+//   qn = arena.copy (pn, bytesn);
+//   assert (bytes1 + ... + bytesn <= bytes);
+//   arena.swap ();
+//   ...
+//   if (!arena.contains (q)) delete q;
+//   ...
+//   arena.prepare (bytes);
+//   q1 = arena.copy (p1, bytes1);
+//   ...
+//   qn = arena.copy (pn, bytesn);
+//   assert (bytes1 + ... + bytesn <= bytes);
+//   arena.swap ();
+//   ...
+//
+// One has to be really careful with 'qi' references to arena memory.
+
+struct Internal;
+
+class Arena {
+
+  Internal * internal;
+
+  struct { char * start, * top, * end; } from, to;
+
+public:
+
+  Arena (Internal *);
+  ~Arena ();
+
+  // Prepare 'to' space to hold that amount of memory.  Precondition is that
+  // the 'to' space is empty.  The following sequence of 'copy' operations
+  // can use as much memory in sum as pre-allocated here.
+  //
+  void prepare (size_t bytes);
+
+  // Does the memory pointed to by 'p' belong to this arena? More precisely
+  // to the 'from' space, since that is the only one remaining after 'swap'.
+  //
+  bool contains (void * p) const {
+    char * c = (char *) p;
+    return from.start <= c && c < from.top;
+  }
+
+  // Allocate that amount of memory in 'to' space.  This assumes the 'to'
+  // space has been prepared to hold enough memory with 'prepare'.  Then
+  // copy the memory pointed to by 'p' of size 'bytes'.  Note that it does
+  // not matter whether 'p' is in 'from' or allocated outside of the arena.
+  //
+  char * copy (const char * p, size_t bytes) {
+    char * res = to.top;
+    to.top += bytes;
+    assert (to.top <= to.end);
+    memcpy (res, p, bytes);
+    return res;
+  }
+
+  // Completely delete 'from' space and then replace 'from' by 'to' (by
+  // pointer swapping).  Everything previously allocated (in 'from') and not
+  // explicitly copied to 'to' with 'copy' becomes invalid.
+  //
+  void swap ();
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/assume.cpp b/hCaD_V2/src/assume.cpp
new file mode 100644
index 0000000..c79cfa8
--- /dev/null
+++ b/hCaD_V2/src/assume.cpp
@@ -0,0 +1,178 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Failed literal handling as pioneered by MiniSAT.  This first function
+// adds an assumption literal onto the assumption stack.
+
+void Internal::assume (int lit) {
+  Flags & f = flags (lit);
+  const unsigned char bit = bign (lit);
+  if (f.assumed & bit) {
+    LOG ("ignoring already assumed %d", lit);
+    return;
+  }
+  LOG ("assume %d", lit);
+  f.assumed |= bit;
+  assumptions.push_back (lit);
+  freeze (lit);
+}
+
+// Find all failing assumptions starting from the one on the assumption
+// stack with the lowest decision level.  This goes back to MiniSAT and is
+// called 'analyze_final' there.
+
+void Internal::failing () {
+
+  START (analyze);
+
+  LOG ("analyzing failing assumptions");
+
+  assert (analyzed.empty ());
+  assert (clause.empty ());
+
+  int first = 0;
+
+  // Try to find two clashing assumptions.
+  //
+  for (auto & lit : assumptions) {
+    if (!assumed (-lit)) continue;
+    first = lit;
+    break;
+  }
+
+  if (first) {
+
+    // TODO: if 'first' is on the root-level, then, as below, we probably
+    // want an empty core.
+
+    clause.push_back (first);
+    clause.push_back (-first);
+
+    Flags & f = flags (first);
+
+    unsigned bit = bign (first);
+    assert (!(f.failed & bit));
+    f.failed |= bit;
+    bit = bign (-first);
+    f.failed |= bit;
+
+  } else {
+
+    // Find an assumption falsified at smallest decision level.
+    //
+    for (auto & lit : assumptions) {
+      const signed char tmp = val (lit);
+      if (tmp >= 0) continue;
+      if (!first || var (first).level > var (lit).level)
+        first = lit;
+    }
+
+    assert (first);
+    LOG ("starting with assumption %d falsified on decision level %d",
+      first, var (first).level);
+
+    if (!var (first).level) {
+
+      // TODO: I think marking this should yield an empty core
+      // and not mark 'first' as failed (similarly above).
+
+      LOG ("failed assumption %d", first);
+      clause.push_back (-first);
+
+      Flags & f = flags (first);
+      const unsigned bit = bign (first);
+      assert (!(f.failed & bit));
+      f.failed |= bit;
+
+    } else {
+
+      // The 'analyzed' stack serves as working stack for a BFS through the
+      // implication graph until decisions, which are all assumptions, or units
+      // are reached.  This is simpler than corresponding code in 'analyze'.
+
+      {
+        LOG ("failed assumption %d", first);
+        Flags & f = flags (first);
+        const unsigned bit = bign (first);
+        assert (!(f.failed & bit));
+        f.failed |= bit;
+        f.seen = true;
+      }
+
+      analyzed.push_back (first);
+      clause.push_back (-first);
+
+      size_t next = 0;
+
+      while (next < analyzed.size ()) {
+        const int lit = analyzed[next++];
+#ifndef NDEBUG
+        if (first == lit) assert (val (lit) < 0);
+        else assert (val (lit) > 0);
+#endif
+        Var & v = var (lit);
+        if (!v.level) continue;
+
+        if (v.reason) {
+          assert (v.level);
+          LOG (v.reason, "analyze reason");
+          for (const auto & other : *v.reason) {
+            Flags & f = flags (other);
+            if (f.seen) continue;
+            f.seen = true;
+            assert (val (other) < 0);
+            analyzed.push_back (-other);
+          }
+        } else {
+          assert (assumed (lit));
+          LOG ("failed assumption %d", lit);
+          clause.push_back (-lit);
+          Flags & f = flags (lit);
+          const unsigned bit = bign (lit);
+          assert (!(f.failed & bit));
+          f.failed |= bit;
+        }
+      }
+      clear_analyzed_literals ();
+
+      // TODO, we can not do clause minimization here, right?
+    }
+  }
+
+  VERBOSE (1, "found %zd failed assumptions %.0f%%",
+    clause.size (), percent (clause.size (), assumptions.size ()));
+
+  // We do not actually need to learn this clause, since the conflict is
+  // forced already by some other clauses.  There is also no bumping
+  // of variables nor clauses necessary.  But we still want to check
+  // correctness of the claim that the determined subset of failing
+  // assumptions are a high-level core or equivalently their negations form
+  // a unit-implied clause.
+  //
+  external->check_learned_clause ();
+  if (proof) {
+    proof->add_derived_clause (clause);
+    proof->delete_clause (clause);
+  }
+  clause.clear ();
+
+  STOP (analyze);
+}
+
+// Add the start of each incremental phase (leaving the state
+// 'UNSATISFIABLE' actually) we reset all assumptions.
+
+void Internal::reset_assumptions () {
+  for (const auto & lit : assumptions) {
+    Flags & f = flags (lit);
+    const unsigned char bit = bign (lit);
+    f.assumed &= ~bit;
+    f.failed &= ~bit;
+    melt (lit);
+  }
+  LOG ("cleared %zd assumptions", assumptions.size ());
+  assumptions.clear ();
+}
+
+}
diff --git a/hCaD_V2/src/averages.cpp b/hCaD_V2/src/averages.cpp
new file mode 100644
index 0000000..9376e6e
--- /dev/null
+++ b/hCaD_V2/src/averages.cpp
@@ -0,0 +1,30 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::init_averages () {
+
+  LOG ("initializing averages");
+
+  INIT_EMA (averages.current.jump, opts.emajump);
+  INIT_EMA (averages.current.level, opts.emalevel);
+  INIT_EMA (averages.current.size, opts.emasize);
+
+  INIT_EMA (averages.current.glue.fast, opts.emagluefast);
+  INIT_EMA (averages.current.glue.slow, opts.emaglueslow);
+
+  INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
+  INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
+
+  assert (!averages.swapped);
+}
+
+void Internal::swap_averages () {
+  LOG ("saving current averages");
+  swap (averages.current, averages.saved);
+  if (!averages.swapped) init_averages ();
+  else LOG ("swapping in previously saved averages");
+  averages.swapped++;
+}
+
+}
diff --git a/hCaD_V2/src/averages.hpp b/hCaD_V2/src/averages.hpp
new file mode 100644
index 0000000..1d4451c
--- /dev/null
+++ b/hCaD_V2/src/averages.hpp
@@ -0,0 +1,36 @@
+#ifndef _averages_hpp_INCLUDED
+#define _averages_hpp_INCLUDED
+
+#include "ema.hpp"              // alphabetically after 'averages.hpp'
+
+namespace CaDiCaL {
+
+struct Averages {
+
+  int64_t swapped;
+
+  struct {
+
+    struct {
+      EMA fast; // average fast (small window) moving glucose level
+      EMA slow; // average slow (large window) moving glucose level
+    } glue;
+
+    struct {
+      EMA fast; // average fast (small window) moving trail level
+      EMA slow; // average slow (large window) moving trail level
+    } trail;
+
+    EMA size;   // average learned clause size
+    EMA jump;   // average (potential non-chronological) back-jump level
+    EMA level;  // average back track level after conflict
+
+  } current, saved;
+
+  Averages () : swapped (0) { }
+
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/backtrack.cpp b/hCaD_V2/src/backtrack.cpp
new file mode 100644
index 0000000..a9a7f62
--- /dev/null
+++ b/hCaD_V2/src/backtrack.cpp
@@ -0,0 +1,125 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// The global assignment stack can only be (partially) reset through
+// 'backtrack' which is the only function using 'unassign' (inlined and thus
+// local to this file).  It turns out that 'unassign' does not need a
+// specialization for 'probe' nor 'vivify' and thus it is shared.
+
+inline void Internal::unassign (int lit) {
+  assert (val (lit) > 0);
+  const int idx = vidx (lit);
+  vals[idx] = 0;
+  vals[-idx] = 0;
+  LOG ("unassign %d @ %d", lit, var (idx).level);
+
+  // In the standard EVSIDS variable decision heuristic of MiniSAT, we need
+  // to push variables which become unassigned back to the heap.
+  //
+  if (!scores.contains (idx)) scores.push_back (idx);
+
+  // For VMTF we need to update the 'queue.unassigned' pointer in case this
+  // variable sits after the variable to which 'queue.unassigned' currently
+  // points.  See our SAT'15 paper for more details on this aspect.
+  //
+  if (queue.bumped < btab[idx]) update_queue_unassigned (idx);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Update the current target maximum assignment and also the very best
+// assignment.  Whether a trail produces a conflict is determined during
+// propagation.  Thus that all functions in the 'search' loop after
+// propagation can assume that 'no_conflict_until' is valid.  If a conflict
+// is found then the trail before the last decision is used (see the end of
+// 'propagate').  During backtracking we can then save this largest
+// propagation conflict free assignment.  It is saved as both 'target'
+// assignment for picking decisions in 'stable' mode and if it is the
+// largest ever such assignment also as 'best' assignment. This 'best'
+// assignment can then be used in future stable decisions after the next
+// 'rephase_best' overwrites saved phases with it.
+
+void Internal::update_target_and_best () {
+
+  bool reset = (rephased && stats.conflicts > last.rephase.conflicts);
+
+  if (reset) {
+    target_assigned = 0;
+    if (rephased == 'B') best_assigned = 0;     // update it again
+  }
+
+  if (no_conflict_until > target_assigned) {
+    copy_phases (phases.target);
+    target_assigned = no_conflict_until;
+    LOG ("new target trail level %zu", target_assigned);
+  }
+
+  if (no_conflict_until > best_assigned) {
+    copy_phases (phases.best);
+    best_assigned = no_conflict_until;
+    LOG ("new best trail level %zu", best_assigned);
+  }
+
+  if (reset) {
+    report (rephased);
+    rephased = 0;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::backtrack (int new_level) {
+
+  assert (new_level <= level);
+  if (new_level == level) return;
+
+  stats.backtracks++;
+  update_target_and_best ();
+
+  const size_t assigned = control[new_level+1].trail;
+
+  LOG ("backtracking to decision level %d with decision %d and trail %zd",
+    new_level, control[new_level].decision, assigned);
+
+  const size_t end_of_trail = trail.size ();
+  size_t i = assigned, j = i;
+
+  int reassigned = 0, unassigned = 0;
+
+  while (i < end_of_trail) {
+    int lit = trail[i++];
+    Var & v = var (lit);
+    if (v.level > new_level) {
+      unassign (lit);
+      unassigned++;
+    } else {
+      // This is the essence of the SAT'18 paper on chronological
+      // backtracking.  It is possible to just keep out-of-order assigned
+      // literals on the trail without breaking the solver (after some
+      // modifications to 'analyze' - see 'opts.chrono' guarded code there).
+      assert (opts.chrono);
+#ifdef LOGGING
+      if (!v.level) LOG ("reassign %d @ 0 unit clause %d", lit, lit);
+      else LOG (v.reason, "reassign %d @ %d", lit, v.level);
+#endif
+      trail[j] = lit;
+      v.trail = j++;
+      reassigned++;
+    }
+  }
+  trail.resize (j);
+  LOG ("unassigned %d literals %.0f%%",
+    unassigned, percent (unassigned, unassigned + reassigned));
+  LOG ("reassigned %d literals %.0f%%",
+    reassigned, percent (reassigned, unassigned + reassigned));
+
+  if (propagated > assigned) propagated = assigned;
+  if (propagated2 > assigned) propagated2 = assigned;
+  if (no_conflict_until > assigned) no_conflict_until = assigned;
+
+  control.resize (new_level + 1);
+  level = new_level;
+}
+
+}
diff --git a/hCaD_V2/src/backward.cpp b/hCaD_V2/src/backward.cpp
new file mode 100644
index 0000000..851de45
--- /dev/null
+++ b/hCaD_V2/src/backward.cpp
@@ -0,0 +1,148 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Provide eager backward subsumption for resolved clauses.
+
+// The eliminator maintains a queue of clauses that are new and have to be
+// checked to subsume or strengthen other (longer or same size) clauses.
+
+void Eliminator::enqueue (Clause * c) {
+  if (!internal->opts.elimbackward) return;
+  if (c->enqueued) return;
+  LOG (c, "backward enqueue");
+  backward.push (c);
+  c->enqueued = true;
+}
+
+Clause * Eliminator::dequeue () {
+  if (backward.empty ()) return 0;
+  Clause * res = backward.front ();
+  backward.pop ();
+  assert (res->enqueued);
+  res->enqueued = false;
+  LOG (res, "backward dequeue");
+  return res;
+}
+
+Eliminator::~Eliminator () {
+  while (dequeue ())
+    ;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim_backward_clause (Eliminator & eliminator, Clause *c) {
+  assert (opts.elimbackward);
+  assert (!c->redundant);
+  if (c->garbage) return;
+  LOG (c, "attempting backward subsumption and strengthening with");
+  size_t len = UINT_MAX;
+  unsigned size = 0;
+  int best = 0;
+  bool satisfied = false;
+  for (const auto & lit : *c) {
+    const signed char tmp = val (lit);
+    if (tmp > 0) { satisfied = true; break; }
+    if (tmp < 0) continue;
+    size_t l = occs (lit).size ();
+    LOG ("literal %d occurs %zd times", lit, l);
+    if (l < len) best = lit, len = l;
+    mark (lit);
+    size++;
+  }
+  if (satisfied) {
+    LOG ("clause actually already satisfied");
+    elim_update_removed_clause (eliminator, c);
+    mark_garbage (c);
+  } else if (len > (size_t) opts.elimocclim) {
+    LOG ("skipping backward subsumption due to too many occurrences");
+  } else {
+    assert (len);
+    LOG ("literal %d has smallest number of occurrences %zd", best, len);
+    LOG ("marked %d literals in clause of size %d", size, c->size);
+    for (auto & d : occs (best)) {
+      if (d == c) continue;
+      if (d->garbage) continue;
+      if ((unsigned) d->size < size) continue;
+      int negated = 0;
+      unsigned found = 0;
+      for (const auto & lit : *d) {
+        signed char tmp = val (lit);
+        if (tmp > 0) { satisfied = true; break; }
+        if (tmp < 0) continue;
+        tmp = marked (lit);
+        if (!tmp) continue;
+        if (tmp < 0) {
+          if (negated) { size = UINT_MAX; break; }
+          else negated = lit;
+        }
+        if (++found == size) break;
+      }
+      if (satisfied) {
+        LOG (d, "found satisfied clause");
+        elim_update_removed_clause (eliminator, d);
+        mark_garbage (d);
+      } else if (found == size) {
+        if (!negated) {
+          LOG (d, "found subsumed clause");
+          elim_update_removed_clause (eliminator, d);
+          mark_garbage (d);
+          stats.subsumed++;
+          stats.elimbwsub++;
+        } else {
+          int unit = 0;
+          for (const auto & lit : * d) {
+            const signed char tmp = val (lit);
+            if (tmp < 0) continue;
+            if (tmp > 0) { satisfied = true; break; }
+            if (lit == negated) continue;
+            if (unit) { unit = INT_MIN; break; }
+            else unit = lit;
+          }
+          assert (unit);
+          if (satisfied) {
+            mark_garbage (d);
+            elim_update_removed_clause (eliminator, d);
+          } else if (unit && unit != INT_MIN) {
+            assert (unit);
+            LOG (d, "unit %d through hyper unary resolution with", unit);
+            assign_unit (unit);
+            elim_propagate (eliminator, unit);
+            break;
+          } else if (occs (negated).size () <= (size_t) opts.elimocclim) {
+            strengthen_clause (d, negated);
+            remove_occs (occs (negated), d);
+            elim_update_removed_lit (eliminator, negated);
+            stats.elimbwstr++;
+            assert (negated != best);
+            eliminator.enqueue (d);
+          }
+        }
+      }
+    }
+  }
+  unmark (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim_backward_clauses (Eliminator & eliminator) {
+  if (!opts.elimbackward) {
+    assert (eliminator.backward.empty ());
+    return;
+  }
+  START (backward);
+  LOG ("attempting backward subsumption and strengthening with %zd clauses",
+    eliminator.backward.size ());
+  Clause * c;
+  while (!unsat && (c = eliminator.dequeue ()))
+    elim_backward_clause (eliminator, c);
+  STOP (backward);
+}
+
+/*------------------------------------------------------------------------*/
+
+}
diff --git a/hCaD_V2/src/bins.cpp b/hCaD_V2/src/bins.cpp
new file mode 100644
index 0000000..8f108a3
--- /dev/null
+++ b/hCaD_V2/src/bins.cpp
@@ -0,0 +1,22 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Binary implication graph lists.
+
+void Internal::init_bins () {
+  assert (big.empty ());
+  while (big.size () < 2*vsize)
+    big.push_back (Bins ());
+  LOG ("initialized binary implication graph");
+}
+
+void Internal::reset_bins () {
+  assert (!big.empty ());
+  erase_vector (big);
+  LOG ("reset binary implication graph");
+}
+
+}
diff --git a/hCaD_V2/src/bins.hpp b/hCaD_V2/src/bins.hpp
new file mode 100644
index 0000000..e55f0f5
--- /dev/null
+++ b/hCaD_V2/src/bins.hpp
@@ -0,0 +1,17 @@
+#ifndef _bins_hpp_INCLUDED
+#define _bins_hpp_INCLUDED
+
+#include "util.hpp"     // Alphabetically after 'bins'.
+
+namespace CaDiCaL {
+
+using namespace std;
+
+typedef vector<int> Bins;
+
+inline void shrink_bins (Bins & bs) { shrink_vector (bs); }
+inline void erase_bins (Bins & bs) { erase_vector (bs); }
+
+}
+
+#endif
diff --git a/hCaD_V2/src/block.cpp b/hCaD_V2/src/block.cpp
new file mode 100644
index 0000000..185053d
--- /dev/null
+++ b/hCaD_V2/src/block.cpp
@@ -0,0 +1,751 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This implements an inprocessing version of blocked clause elimination and
+// is assumed to be triggered just before bounded variable elimination.  It
+// has a separate 'block' flag while variable elimination uses 'elim'.
+// Thus it only tries to block clauses on a literal which was removed in an
+// irredundant clause in negated form before and has not been tried to use
+// as blocking literal since then.
+
+/*------------------------------------------------------------------------*/
+
+inline bool block_more_occs_size::operator () (unsigned a, unsigned b) {
+  size_t s = internal->noccs (-internal->u2i (a));
+  size_t t = internal->noccs (-internal->u2i (b));
+  if (s > t) return true;
+  if (s < t) return false;
+  s = internal->noccs (internal->u2i (a));
+  t = internal->noccs (internal->u2i (b));
+  if (s > t) return true;
+  if (s < t) return false;
+  return a > b;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Determine whether 'c' is blocked on 'lit', by first marking all its
+// literals and then checking all resolvents with negative clauses (with
+// '-lit') are tautological.  We use a move-to-front scheme for both the
+// occurrence list of negative clauses (with '-lit') and then for literals
+// within each such clause.  The clause move-to-front scheme has the goal to
+// find non-tautological clauses faster in the future, while the literal
+// move-to-front scheme has the goal to faster find the matching literal,
+// which makes the resolvent tautological (again in the future).
+
+bool Internal::is_blocked_clause (Clause * c, int lit) {
+
+  LOG (c, "trying to block on %d", lit);
+
+  assert (c->size >= opts.blockminclslim);
+  assert (c->size <= opts.blockmaxclslim);
+  assert (active (lit));
+  assert (!val (lit));
+  assert (!c->garbage);
+  assert (!c->redundant);
+  assert (!level);
+
+  mark (c);             // First mark all literals in 'c'.
+
+  Occs & os = occs (-lit);
+  LOG ("resolving against at most %zd clauses with %d", os.size (), -lit);
+
+  bool res = true;      // Result is true if all resolvents tautological.
+
+  // Can not use 'auto' here since we update 'os' during traversal.
+  //
+  const auto end_of_os = os.end ();
+  auto i = os.begin ();
+
+  Clause * prev_d = 0;  // Previous non-tautological clause.
+
+  for (; i != end_of_os; i++)
+  {
+    // Move the first clause with non-tautological resolvent to the front of
+    // the occurrence list to improve finding it faster later.
+    //
+    Clause * d = *i;
+
+    assert (!d->garbage);
+    assert (!d->redundant);
+    assert (d->size <= opts.blockmaxclslim);
+
+    *i = prev_d;        // Move previous non-tautological clause
+    prev_d = d;         // backwards but remember clause at this position.
+
+    LOG (d, "resolving on %d against", lit);
+    stats.blockres++;
+
+    int prev_other = 0; // Previous non-tautological literal.
+
+    // No 'auto' since we update literals of 'd' during traversal.
+    //
+    const const_literal_iterator end_of_d = d->end ();
+    literal_iterator l;
+
+    for (l = d->begin (); l != end_of_d; l++)
+    {
+      // Same move-to-front mechanism for literals within a clause.  It
+      // moves the first negatively marked literal to the front to find it
+      // faster in the future.
+      //
+      const int other = *l;
+      *l = prev_other;
+      prev_other = other;
+      if (other == -lit) continue;
+      assert (other != lit);
+      assert (active (other));
+      assert (!val (other));
+      if (marked (other) < 0) {
+        LOG ("found tautological literal %d", other);
+        d->literals[0] = other;         // Move to front of 'd'.
+        break;
+      }
+    }
+
+    if (l == end_of_d)
+    {
+      LOG ("no tautological literal found");
+      //
+      // Since we did not find a tautological literal we restore the old
+      // order of literals in the clause.
+      //
+      const const_literal_iterator begin_of_d = d->begin ();
+      while (l-- != begin_of_d) {
+        const int other = *l;
+        *l = prev_other;
+        prev_other = other;
+      }
+      res = false;  // Now 'd' is a witness that 'c' is not blocked.
+      os[0] = d;    // Move it to the front of the occurrence list.
+      break;
+    }
+  }
+  unmark (c);       // ... all literals of the candidate clause.
+
+  // If all resolvents are tautological and thus the clause is blocked we
+  // restore the old order of clauses in the occurrence list of '-lit'.
+  //
+  if (res) {
+    assert (i == end_of_os);
+    const auto boc = os.begin ();
+    while (i != boc) {
+      Clause * d = *--i;
+      *i = prev_d;
+      prev_d = d;
+    }
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::block_schedule (Blocker & blocker)
+{
+  // Set skip flags for all literals in too large clauses.
+  //
+  for (const auto & c : clauses) {
+
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+    if (c->size <= opts.blockmaxclslim) continue;
+
+    for (const auto & lit : *c)
+      mark_skip (-lit);
+  }
+
+  // Connect all literal occurrences in irredundant clauses.
+  //
+  for (const auto & c : clauses) {
+
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+
+    for (const auto & lit : *c) {
+      assert (active (lit));
+      assert (!val (lit));
+      occs (lit).push_back (c);
+    }
+  }
+
+  // We establish the invariant that 'noccs' gives the number of actual
+  // occurrences of 'lit' in non-garbage clauses,  while 'occs' might still
+  // refer to garbage clauses, thus 'noccs (lit) <= occs (lit).size ()'.  It
+  // is expensive to remove references to garbage clauses from 'occs' during
+  // blocked clause elimination, but decrementing 'noccs' is cheap.
+
+  for (auto lit : lits) {
+    if (!active (lit)) continue;
+    assert (!val (lit));
+    Occs & os = occs (lit);
+    noccs (lit) = os.size ();
+  }
+
+  // Now we fill the schedule (priority queue) of candidate literals to be
+  // tried as blocking literals.  It is probably slightly faster to do this
+  // in one go after all occurrences have been determined, instead of
+  // filling the priority queue during pushing occurrences.  Filling the
+  // schedule can not be fused with the previous loop (easily) since we
+  // first have to initialize 'noccs' for both 'lit' and '-lit'.
+
+  int skipped = 0;
+
+  for (auto idx : vars) {
+    if (!active (idx)) continue;
+    if (frozen (idx)) { skipped += 2; continue; }
+    assert (!val (idx));
+    for (int sign = -1; sign <= 1; sign += 2) {
+      const int lit = sign * idx;
+      if (marked_skip (lit)) { skipped++; continue; }
+      if (!marked_block (lit)) continue;
+      unmark_block (lit);
+      LOG ("scheduling %d with %" PRId64 " positive and %" PRId64 " negative occurrences",
+        lit, noccs (lit), noccs (-lit));
+      blocker.schedule.push_back (vlit (lit));
+    }
+  }
+
+  PHASE ("block", stats.blockings,
+    "scheduled %zd candidate literals %.2f%% (%d skipped %.2f%%)",
+    blocker.schedule.size (),
+    percent (blocker.schedule.size (), 2.0*active ()),
+    skipped, percent (skipped, 2.0*active ()));
+}
+
+/*------------------------------------------------------------------------*/
+
+// A literal is pure if it only occurs positive.  Then all clauses in which
+// it occurs are blocked on it. This special case can be implemented faster
+// than trying to block literals with at least one negative occurrence and
+// is thus handled separately.  It also allows to avoid pushing blocked
+// clauses onto the extension stack.
+
+void Internal::block_pure_literal (Blocker & blocker, int lit)
+{
+  if (frozen (lit)) return;
+  assert (active (lit));
+
+  Occs & pos = occs (lit);
+  Occs & nos = occs (-lit);
+
+  assert (!noccs (-lit));
+#ifndef NDEBUG
+  for (const auto & c : nos) assert (c->garbage);
+#endif
+  stats.blockpurelits++;
+  LOG ("found pure literal %d", lit);
+
+  int64_t pured = 0;
+
+  for (const auto & c : pos) {
+    if (c->garbage) continue;
+    assert (!c->redundant);
+    LOG (c, "pure literal %d in", lit);
+    blocker.reschedule.push_back (c);
+    external->push_clause_on_extension_stack (c, lit);
+    stats.blockpured++;
+    mark_garbage (c);
+    pured++;
+  }
+
+  erase_vector (pos);
+  erase_vector (nos);
+
+  mark_pure (lit);
+  stats.blockpured++;
+  LOG ("blocking %" PRId64 " clauses on pure literal %d", pured, lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// If there is only one negative clause with '-lit' it is faster to mark it
+// instead of marking all the positive clauses with 'lit' one after the
+// other and then resolving against the negative clause.
+
+void
+Internal::block_literal_with_one_negative_occ (Blocker & blocker, int lit)
+{
+  assert (active (lit));
+  assert (!frozen (lit));
+  assert (noccs (lit) > 0);
+  assert (noccs (-lit) == 1);
+
+  Occs & nos = occs (-lit);
+  assert (nos.size () >= 1);
+
+  Clause * d = 0;
+  for (const auto & c : nos) {
+    if (c->garbage) continue;
+    assert (!d);
+    d = c;
+#ifndef NDEBUG
+    break;
+#endif
+  }
+  assert (d);
+  nos.resize (1);
+  nos[0] = d;
+
+  if (d && d->size > opts.blockmaxclslim) {
+    LOG (d, "skipped common antecedent");
+    return;
+  }
+
+  assert (!d->garbage);
+  assert (!d->redundant);
+  assert (d->size <= opts.blockmaxclslim);
+
+  LOG (d, "common %d antecedent", lit);
+  mark (d);
+
+  int64_t blocked = 0, skipped = 0;
+
+  Occs & pos = occs (lit);
+
+  // Again no 'auto' since 'pos' is update during traversal.
+  //
+  const auto eop = pos.end ();
+  auto j = pos.begin (), i = j;
+
+  for (; i != eop; i++)
+  {
+    Clause * c = *j++ = *i;
+
+    if (c->garbage) { j--; continue; }
+    if (c->size > opts.blockmaxclslim) { skipped++; continue; }
+    if (c->size < opts.blockminclslim) { skipped++; continue; }
+
+    LOG (c, "trying to block on %d", lit);
+
+    // We use the same literal move-to-front strategy as in
+    // 'is_blocked_clause'.  See there for more explanations.
+
+    int prev_other = 0;  // Previous non-tautological literal.
+
+    // No 'auto' since literals of 'c' are updated during traversal.
+    //
+    const const_literal_iterator end_of_c = c->end ();
+    literal_iterator l;
+
+    for (l = c->begin (); l != end_of_c; l++)
+    {
+      const int other = *l;
+      *l = prev_other;
+      prev_other = other;
+      if (other == lit) continue;
+      assert (other != -lit);
+      assert (active (other));
+      assert (!val (other));
+      if (marked (other) < 0) {
+        LOG ("found tautological literal %d", other);
+        c->literals[0] = other; // Move to front of 'c'.
+        break;
+      }
+    }
+
+    if (l == end_of_c) {
+      LOG ("no tautological literal found");
+
+      // Restore old literal order in the clause because.
+
+      const const_literal_iterator begin_of_c = c->begin ();
+      while (l-- != begin_of_c) {
+        const int other = *l;
+        *l = prev_other;
+        prev_other = other;
+      }
+
+      continue; // ... with next candidate 'c' in 'pos'.
+    }
+
+    blocked++;
+    LOG (c, "blocked");
+    external->push_clause_on_extension_stack (c, lit);
+    blocker.reschedule.push_back (c);
+    mark_garbage (c);
+    j--;
+  }
+  if (j == pos.begin ()) erase_vector (pos);
+  else pos.resize (j - pos.begin ());
+
+  stats.blocked += blocked;
+  LOG ("blocked %" PRId64 " clauses on %d (skipped %" PRId64 ")", blocked, lit, skipped);
+
+  unmark (d);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Determine the set of candidate clauses with 'lit', which are checked to
+// be blocked by 'lit'.  Filter out too large and small clauses and which do
+// not have any negated other literal in any of the clauses with '-lit'.
+
+size_t Internal::block_candidates (Blocker & blocker, int lit) {
+
+  assert (blocker.candidates.empty ());
+
+  Occs & pos = occs (lit);      // Positive occurrences of 'lit'.
+  Occs & nos = occs (-lit);
+
+  assert ((size_t) noccs (lit) <= pos.size ());
+  assert ((size_t) noccs (-lit) == nos.size ());  // Already flushed.
+
+  // Mark all literals in clauses with '-lit'.  Note that 'mark2' uses
+  // separate bits for 'lit' and '-lit'.
+  //
+  for (const auto & c : nos) mark2 (c);
+
+  const auto eop = pos.end ();
+  auto j = pos.begin (), i = j;
+
+  for (; i != eop; i++)
+  {
+    Clause * c = *j++ = *i;
+    if (c->garbage) { j--; continue; }
+    assert (!c->redundant);
+    if (c->size > opts.blockmaxclslim) continue;
+    if (c->size < opts.blockminclslim) continue;
+    const const_literal_iterator eoc = c->end ();
+    const_literal_iterator l;
+    for (l = c->begin (); l != eoc; l++) {
+      const int other = *l;
+      if (other == lit) continue;
+      assert (other != -lit);
+      assert (active (other));
+      assert (!val (other));
+      if (marked2 (-other)) break;
+    }
+    if (l != eoc) blocker.candidates.push_back (c);
+  }
+  if (j == pos.begin ()) erase_vector (pos);
+  else pos.resize (j - pos.begin ());
+
+  assert (pos.size () == (size_t) noccs (lit)); // Now also flushed.
+
+  for (const auto & c : nos) unmark (c);
+
+  return blocker.candidates.size ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to find a clause with '-lit' which does not have any literal in
+// clauses with 'lit'.  If such a clause exists no candidate clause can be
+// blocked on 'lit' since all candidates would produce a non-tautological
+// resolvent with that clause.
+
+Clause * Internal::block_impossible (Blocker & blocker, int lit)
+{
+  assert (noccs (-lit) > 1);
+  assert (blocker.candidates.size () > 1);
+
+  for (const auto & c : blocker.candidates) mark2 (c);
+
+  Occs & nos = occs (-lit);
+  Clause * res = 0;
+
+  for (const auto & c : nos) {
+    assert (!c->garbage);
+    assert (!c->redundant);
+    assert (c->size <= opts.blockmaxclslim);
+    const const_literal_iterator eoc = c->end ();
+    const_literal_iterator l;
+    for (l = c->begin (); l != eoc; l++) {
+      const int other = *l;
+      if (other == -lit) continue;
+      assert (other != lit);
+      assert (active (other));
+      assert (!val (other));
+      if (marked2 (-other)) break;
+    }
+    if (l == eoc) res = c;
+  }
+
+  for (const auto & c : blocker.candidates) unmark (c);
+
+  if (res) {
+    LOG (res, "common non-tautological resolvent producing");
+    blocker.candidates.clear ();
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// In the general case we have at least two negative occurrences.
+
+void Internal::block_literal_with_at_least_two_negative_occs (
+  Blocker & blocker,
+  int lit)
+{
+  assert (active (lit));
+  assert (!frozen (lit));
+  assert (noccs (lit) > 0);
+  assert (noccs (-lit) > 1);
+
+  Occs & nos = occs (-lit);
+  assert ((size_t) noccs (-lit) <= nos.size ());
+
+  int max_size = 0;
+
+  // Flush all garbage clauses in occurrence list 'nos' of '-lit' and
+  // determine the maximum size of negative clauses (with '-lit').
+  //
+  const auto eon = nos.end ();
+  auto j = nos.begin (), i = j;
+  for (; i != eon; i++)
+  {
+    Clause * c = *j++ = *i;
+    if (c->garbage) j--;
+    else if (c->size > max_size) max_size = c->size;
+  }
+  if (j == nos.begin ()) erase_vector (nos);
+  else nos.resize (j - nos.begin ());
+
+  assert (nos.size () == (size_t) noccs (-lit));
+  assert (nos.size () > 1);
+
+  // If the maximum size of a negative clause (with '-lit') exceeds the
+  // maximum clause size limit ignore this candidate literal.
+  //
+  if (max_size > opts.blockmaxclslim) {
+    LOG ("maximum size %d of clauses with %d exceeds clause size limit %d",
+      max_size, -lit, opts.blockmaxclslim);
+    return;
+  }
+
+  LOG ("maximum size %d of clauses with %d", max_size, -lit);
+
+  // We filter candidate clauses with positive occurrence of 'lit' in
+  // 'blocker.candidates' and return if no candidate clause remains.
+  // Candidates should be small enough and should have at least one literal
+  // which occurs negated in one of the clauses with '-lit'.
+  //
+  size_t candidates = block_candidates (blocker, lit);
+  if (!candidates) {
+    LOG ("no candidate clauses found");
+    return;
+  }
+
+  LOG ("found %zd candidate clauses", candidates);
+
+  // We further search for a clause with '-lit' that has no literal
+  // negated in any of the candidate clauses (except 'lit').  If such a
+  // clause exists, we know that none of the candidates is blocked.
+  //
+  if (candidates > 1 && block_impossible (blocker, lit)) {
+    LOG ("impossible to block any candidate clause on %d", lit);
+    assert (blocker.candidates.empty ());
+    return;
+  }
+
+  LOG ("trying to block %zd clauses out of %" PRId64 " with literal %d",
+    candidates, noccs (lit), lit);
+
+  int64_t blocked = 0;
+
+  // Go over all remaining candidates and try to block them on 'lit'.
+  //
+  for (const auto & c : blocker.candidates) {
+    assert (!c->garbage);
+    assert (!c->redundant);
+    if (!is_blocked_clause (c, lit)) continue;
+    blocked++;
+    LOG (c, "blocked");
+    external->push_clause_on_extension_stack (c, lit);
+    blocker.reschedule.push_back (c);
+    mark_garbage (c);
+  }
+
+  LOG ("blocked %" PRId64 " clauses on %d out of %zd candidates in %zd occurrences",
+    blocked, lit, blocker.candidates.size (), occs (lit).size ());
+
+  blocker.candidates.clear ();
+  stats.blocked += blocked;
+  if (blocked) flush_occs (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Reschedule literals in a clause (except 'lit') which was blocked.
+
+void
+Internal::block_reschedule_clause (Blocker & blocker, int lit, Clause * c)
+{
+#ifdef NDEBUG
+  (void) lit;
+#endif
+  assert (c->garbage);
+
+  for (const auto & other : *c) {
+
+    int64_t & n = noccs (other);
+    assert (n > 0);
+    n--;
+
+    LOG ("updating %d with %" PRId64 " positive and %" PRId64 " negative occurrences",
+      other, noccs (other), noccs (-other));
+
+    if (blocker.schedule.contains (vlit (-other)))
+      blocker.schedule.update (vlit (-other));
+    else if (active (other) &&
+             !frozen (other) &&
+             !marked_skip (-other)) {
+      LOG ("rescheduling to block clauses on %d", -other);
+      blocker.schedule.push_back (vlit (-other));
+    }
+
+    if (blocker.schedule.contains (vlit (other))) {
+      assert (other != lit);
+      blocker.schedule.update (vlit (other));
+    }
+  }
+}
+
+// Reschedule all literals in clauses blocked by 'lit' (except 'lit').
+
+void Internal::block_reschedule (Blocker & blocker, int lit)
+{
+  while (!blocker.reschedule.empty ()) {
+    Clause * c = blocker.reschedule.back ();
+    blocker.reschedule.pop_back ();
+    block_reschedule_clause (blocker, lit, c);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::block_literal (Blocker & blocker, int lit)
+{
+  assert (!marked_skip (lit));
+
+  if (!active (lit)) return; // Pure literal '-lit'.
+  if (frozen (lit)) return;
+
+  assert (!val (lit));
+
+  // If the maximum number of a negative clauses (with '-lit') exceeds the
+  // occurrence limit ignore this candidate literal.
+  //
+  if (noccs (-lit) > opts.blockocclim) return;
+
+  LOG ("blocking literal candidate %d "
+    "with %" PRId64 " positive and %" PRId64 " negative occurrences",
+    lit, noccs (lit), noccs (-lit));
+
+  stats.blockcands++;
+
+  assert (blocker.reschedule.empty ());
+  assert (blocker.candidates.empty ());
+
+  if (!noccs (-lit)) block_pure_literal (blocker, lit);
+  else if (!noccs (lit)) {
+    // Rare situation, where the clause length limit was hit for 'lit' and
+    // '-lit' is skipped and then it becomes pure.  Can be ignored.  We also
+    // so it once happing for a 'elimboundmin=-1' and zero positive and one
+    // negative occurrence.
+  } else if (noccs (-lit) == 1)
+    block_literal_with_one_negative_occ (blocker, lit);
+  else
+    block_literal_with_at_least_two_negative_occs (blocker, lit);
+
+  // Done with blocked clause elimination on this literal and we do not
+  // have to try blocked clause elimination on it again until irredundant
+  // clauses with its negation are removed.
+  //
+  assert (!frozen (lit));       // just to be sure ...
+  unmark_block (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::block () {
+
+  if (!opts.block) return false;
+  if (unsat) return false;
+  if (!stats.current.irredundant) return false;
+  if (terminated_asynchronously ()) return false;
+
+  if (propagated < trail.size ()) {
+    LOG ("need to propagate %zd units first", trail.size () - propagated);
+    init_watches ();
+    connect_watches ();
+    if (!propagate ()) {
+      LOG ("propagating units results in empty clause");
+      learn_empty_clause ();
+      assert (unsat);
+    }
+    clear_watches ();
+    reset_watches ();
+    if (unsat) return false;
+  }
+
+  START_SIMPLIFIER (block, BLOCK);
+
+  stats.blockings++;
+
+  LOG ("block-%" PRId64 "", stats.blockings);
+
+  assert (!level);
+  assert (!watching ());
+  assert (!occurring ());
+
+  mark_satisfied_clauses_as_garbage ();
+
+  init_occs ();  // Occurrence lists for all literals.
+  init_noccs (); // Number of occurrences to avoid flushing garbage clauses.
+
+  Blocker blocker (this);
+  block_schedule (blocker);
+
+  int64_t blocked = stats.blocked;
+  int64_t resolutions = stats.blockres;
+  int64_t purelits = stats.blockpurelits;
+  int64_t pured = stats.blockpured;
+
+  while (!terminated_asynchronously () &&
+         !blocker.schedule.empty ()) {
+    int lit = u2i (blocker.schedule.front ());
+    blocker.schedule.pop_front ();
+    block_literal (blocker, lit);
+    block_reschedule (blocker, lit);
+  }
+
+  blocker.erase ();
+  reset_noccs ();
+  reset_occs ();
+
+  resolutions = stats.blockres - resolutions;
+  blocked = stats.blocked - blocked;
+
+  PHASE ("block", stats.blockings,
+    "blocked %" PRId64 " clauses in %" PRId64 " resolutions",
+    blocked, resolutions);
+
+  pured = stats.blockpured - pured;
+  purelits = stats.blockpurelits - purelits;
+
+  if (pured)
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+
+  if (purelits)
+    PHASE ("block", stats.blockings,
+      "found %" PRId64 " pure literals in %" PRId64 " clauses",
+      purelits, pured);
+  else
+    PHASE ("block", stats.blockings,
+      "no pure literals found");
+
+  report ('b', !opts.reportall && !blocked);
+
+  STOP_SIMPLIFIER (block, BLOCK);
+
+  return blocked;
+}
+
+}
diff --git a/hCaD_V2/src/block.hpp b/hCaD_V2/src/block.hpp
new file mode 100644
index 0000000..04ce12e
--- /dev/null
+++ b/hCaD_V2/src/block.hpp
@@ -0,0 +1,37 @@
+#ifndef _block_hpp_INCLUDED
+#define _block_hpp_INCLUDED
+
+#include "heap.hpp"     // Alphabetically after 'block.hpp'.
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct block_more_occs_size {
+  Internal * internal;
+  block_more_occs_size (Internal * i) : internal (i) { }
+  bool operator () (unsigned a, unsigned b);
+};
+
+typedef heap<block_more_occs_size> BlockSchedule;
+
+class Blocker {
+
+  friend struct Internal;
+
+  vector<struct Clause*> candidates;
+  vector<struct Clause*> reschedule;
+  BlockSchedule schedule;
+
+  Blocker (Internal * i) : schedule (block_more_occs_size (i)) { }
+
+  void erase () {
+    erase_vector (candidates);
+    erase_vector (reschedule);
+    schedule.erase ();
+  }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/cadical.cpp b/hCaD_V2/src/cadical.cpp
new file mode 100644
index 0000000..37293e6
--- /dev/null
+++ b/hCaD_V2/src/cadical.cpp
@@ -0,0 +1,933 @@
+/*------------------------------------------------------------------------*/
+
+// Do include 'internal.hpp' but try to minimize internal dependencies.
+
+#include "internal.hpp"
+#include "signal.hpp"           // Separate, only need for apps.
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+// A wrapper app which makes up the CaDiCaL stand alone solver.  It in
+// essence only consists of the 'App::main' function.  So this class
+// contains code, which is not required if only the library interface in
+// the class 'Solver' is used (defined in 'cadical.hpp').  It further uses
+// static data structures in order to have a signal handler catch signals.
+//
+// It is thus neither thread-safe nor reentrant.  If you want to use
+// multiple instances of the solver use the 'Solver' interface directly
+// which is thread-safe and reentrant among different solver instances.
+
+/*------------------------------------------------------------------------*/
+
+class App : public Handler, public Terminator {
+
+  Solver * solver;                // Global solver.
+
+#ifndef __WIN32
+  // Command line options.
+  //
+  int time_limit;               // '-t <sec>'
+#endif
+
+  // Strictness of (DIMACS) parsing:
+  //
+  //  0 = force parsing and completely ignore header
+  //  1 = relaxed header handling (default)
+  //  2 = strict header handling
+  //
+  // To use '0' use '-f' of '--force'.
+  // To use '2' use '--strict'.
+  //
+  int force_strict_parsing;
+
+  bool force_writing;
+  static bool most_likely_existing_cnf_file (const char * path);
+
+  // Internal variables.
+  //
+  int max_var;                  // Set after parsing.
+  volatile bool timesup;        // Asynchronous termination.
+
+  // Printing.
+  //
+  void print_usage (bool all = false);
+  void print_witness (FILE *);
+
+#ifndef QUIET
+  void signal_message (const char * msg, int sig);
+#endif
+
+  // Option handling.
+  //
+  bool set (const char*);
+  bool set (const char*, int);
+  int  get (const char*);
+  bool verbose () { return get ("verbose") && !get ("quiet"); }
+
+  /*----------------------------------------------------------------------*/
+
+  // The actual initialization.
+  //
+  void init ();
+
+  // Terminator interface.
+  //
+  bool terminate () { return timesup; }
+
+  // Handler interface.
+  //
+  void catch_signal (int sig);
+  void catch_alarm ();
+
+public:
+
+  App ();
+  ~App ();
+
+  // Parse the arguments and run the solver.
+  //
+  int main (int arg, char ** argv);
+};
+
+/*------------------------------------------------------------------------*/
+
+void App::print_usage (bool all) {
+  printf (
+"usage: cadical [ <option> ... ] [ <input> [ <proof> ] ]\n"
+"\n"
+"where '<option>' is one of the following common options:\n"
+"\n");
+
+  if (!all) {      // Print only a short list of common options.
+    printf (
+"  -h             print this short list of common options\n"
+"  --help         print complete list of all options\n"
+"  --version      print version\n"
+"\n"
+"  -n             do not print witness\n"
+#ifndef QUIET
+"  -v             increase verbosity\n"
+"  -q             be quiet\n"
+#endif
+"\n"
+#ifndef __WIN32
+"  -t <sec>       set wall clock time limit\n"
+#endif
+    );
+  } else {         // Print complete list of all options.
+    printf (
+"  -h             print alternatively only a list of common options\n"
+"  --help         print this complete list of all options\n"
+"  --version      print version\n"
+"\n"
+"  -n             do not print witness (same as '--no-witness')\n"
+#ifndef QUIET
+"  -v             increase verbosity (see also '--verbose' below)\n"
+"  -q             be quiet (same as '--quiet')\n"
+#endif
+#ifndef __WIN32
+"  -t <sec>       set wall clock time limit\n"
+#endif
+"\n"
+"Or '<option>' is one of the less common options\n"
+"\n"
+"  -L<rounds>     run local search initially (default '0' rounds)\n"
+"  -O<level>      increase limits by '2^<level>' or '10^<level>'\n"
+"  -P<rounds>     initial preprocessing (default '0' rounds)\n"
+"\n"
+"Note there is no separating space for the options above while the\n"
+"following options require a space after the option name:\n"
+"\n"
+"  -c <limit>     limit the number of conflicts (default unlimited)\n"
+"  -d <limit>     limit the number of decisions (default unlimited)\n"
+"\n"
+"  -o <output>    write simplified CNF in DIMACS format to file\n"
+"  -e <extend>    write reconstruction/extension stack to file\n"
+#ifdef LOGGING
+"  -l             enable logging messages (same as '--log')\n"
+#endif
+"\n"
+"  --force | -f   parsing broken DIMACS header and writing proofs\n"
+"  --strict       strict parsing (no white space in header)\n"
+"\n"
+"  -r <sol>       read solution in competition output format\n"
+"                 to check consistency of learned clauses\n"
+"                 during testing and debugging\n"
+"\n"
+"  -w <sol>       write result including a potential witness\n"
+"                 solution in competition format to the given file\n"
+"\n"
+"  --colors       force colored output\n"
+"  --no-colors    disable colored output to terminal\n"
+"  --no-witness   do not print witness (see also '-n' above)\n"
+"\n"
+"  --build        print build configuration\n"
+"  --copyright    print copyright information\n"
+    );
+
+    printf (
+"\n"
+"There are pre-defined configurations of advanced internal options:\n"
+"\n");
+
+    solver->configurations ();
+
+    printf (
+"\n"
+"Or '<option>' is one of the following advanced internal options:\n"
+"\n");
+    solver->usage ();
+
+    fputs (
+"\n"
+"The internal options have their default value printed in brackets\n"
+"after their description.  They can also be used in the form\n"
+"'--<name>' which is equivalent to '--<name>=1' and in the form\n"
+"'--no-<name>' which is equivalent to '--<name>=0'.  One can also\n"
+"use 'true' instead of '1', 'false' instead of '0', as well as\n"
+"numbers with positive exponent such as '1e3' instead of '1000'.\n"
+"\n"
+"Alternatively option values can also be specified in the header\n"
+"of the DIMACS file, e.g., 'c --elim=false', or through environment\n"
+"variables, such as 'CADICAL_ELIM=false'.  The embedded options in\n"
+"the DIMACS file have highest priority, followed by command line\n"
+"options and then values specified through environment variables.\n",
+     stdout);
+  }
+
+  //------------------------------------------------------------------------
+  // Common to both complete and common option usage.
+
+  fputs (
+"\n"
+"The input is read from '<input>' assumed to be in DIMACS format.\n"
+"Incremental 'p inccnf' files are supported too with cubes at the end.\n"
+"If '<proof>' is given then a DRAT proof is written to that file.\n",
+   stdout);
+
+  //------------------------------------------------------------------------
+  // More explanations for complete option usage.
+
+  if (all) {
+    fputs (
+"\n"
+"If '<input>' is missing then the solver reads from '<stdin>',\n"
+"also if '-' is used as input path name '<input>'.  Similarly,\n"
+"\n"
+"For incremental files each cube is solved in turn. The solver\n"
+"stops at the first satisfied cube if there is one and uses that\n"
+"one for the witness to print.  Conflict and decision limits are\n"
+"applied to each individual cube solving call while '-P', '-L'"
+#ifdef __WIN32
+"\n"
+#else
+" and\n"
+"'-t' "
+#endif
+"remain global.  Only if all cubes were unsatisfiable the solver\n"
+"prints the standard unsatisfiable solution line ('s UNSATISFIABLE').\n"
+"\n"
+"By default the proof is stored in the binary DRAT format unless\n"
+"the option '--no-binary' is specified or the proof is written\n"
+"to  '<stdout>' and '<stdout>' is connected to a terminal.\n"
+"\n"
+"The input is assumed to be compressed if it is given explicitly\n"
+"and has a '.gz', '.bz2', '.xz' or '.7z' suffix.  The same applies\n"
+"to the output file.  In order to use compression and decompression\n"
+"the corresponding utilities 'gzip', 'bzip', 'xz', and '7z' (depending\n"
+"on the format) are required and need to be installed on the system.\n"
+"The solver checks file type signatures though and falls back to\n"
+"non-compressed file reading if the signature does not match.\n",
+    stdout);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Pretty print competition format witness with 'v' lines.
+
+void App::print_witness (FILE * file) {
+  int c = 0, i = 0, tmp;
+  do {
+    if (!c) fputc ('v', file), c = 1;
+    if (i++ == max_var) tmp = 0;
+    else tmp = solver->val (i) < 0 ? -i : i;
+    char str[20];
+    sprintf (str, " %d", tmp);
+    int l = strlen (str);
+    if (c + l > 78) fputs ("\nv", file), c = 1;
+    fputs (str, file);
+    c += l;
+  } while (tmp);
+  if (c) fputc ('\n', file);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Wrapper around option setting.
+
+int App::get (const char * o) { return solver->get (o); }
+bool App::set (const char * o, int v) { return solver->set (o, v); }
+bool App::set (const char * arg) { return solver->set_long_option (arg); }
+
+/*------------------------------------------------------------------------*/
+
+bool App::most_likely_existing_cnf_file (const char * path)
+{
+  if (!File::exists (path)) return false;
+
+  if (has_suffix (path, ".dimacs")) return true;
+  if (has_suffix (path, ".dimacs.gz")) return true;
+  if (has_suffix (path, ".dimacs.xz")) return true;
+  if (has_suffix (path, ".dimacs.bz2")) return true;
+  if (has_suffix (path, ".dimacs.7z")) return true;
+  if (has_suffix (path, ".dimacs.lzma")) return true;
+
+  if (has_suffix (path, ".cnf")) return true;
+  if (has_suffix (path, ".cnf.gz")) return true;
+  if (has_suffix (path, ".cnf.xz")) return true;
+  if (has_suffix (path, ".cnf.bz2")) return true;
+  if (has_suffix (path, ".cnf.7z")) return true;
+  if (has_suffix (path, ".cnf.lzma")) return true;
+
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Short-cut for errors to avoid a hard 'exit'.
+
+#define APPERR(...) \
+do { solver->error (__VA_ARGS__); } while (0)
+
+/*------------------------------------------------------------------------*/
+
+int App::main (int argc, char ** argv) {
+
+  // Handle options which lead to immediate exit first.
+
+  if (argc == 2) {
+    const char * arg = argv[1];
+    if (!strcmp (arg, "-h")) {
+      print_usage ();
+      return 0;
+    } else if (!strcmp (arg, "--help")) {
+      print_usage (true);
+      return 0;
+    } else if (!strcmp (arg, "--version")) {
+      printf ("%s\n", CaDiCaL::version ());
+      return 0;
+    } else if (!strcmp (arg, "--build")) {
+      tout.disable ();
+      Solver::build (stdout, "");
+      return 0;
+    } else if (!strcmp (arg, "--copyright")) {
+      printf ("%s\n", copyright ());
+      return 0;
+    }
+  }
+
+  // Now initialize solver.
+
+  init ();
+
+  // Set all argument option values to not used yet.
+
+  const char * preprocessing_specified = 0, * optimization_specified = 0;
+  const char * read_solution_path = 0, * write_result_path = 0;
+  const char * dimacs_path = 0, * proof_path = 0;
+  bool proof_specified = false, dimacs_specified = false;
+  int optimize = 0, preprocessing = 0, localsearch = 0;
+  const char * output_path = 0, * extension_path = 0;
+  int conflict_limit = -1, decision_limit = -1;
+  const char * conflict_limit_specified = 0;
+  const char * decision_limit_specified = 0;
+  const char * localsearch_specified = 0;
+  const char * time_limit_specified = 0;
+  bool witness = true, less = false;
+  const char * dimacs_name, * err;
+
+  for (int i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h") ||
+        !strcmp (argv[i], "--help") ||
+        !strcmp (argv[i], "--build") ||
+        !strcmp (argv[i], "--version") ||
+        !strcmp (argv[i], "--copyright")) {
+      APPERR ("can only use '%s' as single first option", argv[i]);
+    } else if (!strcmp (argv[i], "-")) {
+      if (proof_specified) APPERR ("too many arguments");
+      else if (!dimacs_specified) dimacs_specified = true;
+      else                         proof_specified = true;
+    } else if (!strcmp (argv[i], "-r")) {
+      if (++i == argc) APPERR ("argument to '-r' missing");
+      else if (read_solution_path)
+        APPERR ("multiple read solution file options '-r %s' and '-r %s'",
+                read_solution_path, argv[i]);
+      else read_solution_path = argv[i];
+    } else if (!strcmp (argv[i], "-w")) {
+      if (++i == argc) APPERR ("argument to '-w' missing");
+      else if (write_result_path)
+        APPERR ("multiple solution file options '-w %s' and '-w %s'",
+                write_result_path, argv[i]);
+      else write_result_path = argv[i];
+    } else if (!strcmp (argv[i], "-o")) {
+      if (++i == argc) APPERR ("argument to '-o' missing");
+      else if (output_path)
+        APPERR ("multiple output file options '-o %s' and '-o %s'",
+          output_path, argv[i]);
+      else if (!force_writing &&
+               most_likely_existing_cnf_file (argv[i]))
+        APPERR ("output file '%s' most likely existing CNF (use '-f')",
+                argv[i]);
+      else if (!File::writable (argv[i]))
+        APPERR ("output file '%s' not writable", argv[i]);
+      else output_path = argv[i];
+    } else if (!strcmp (argv[i], "-e")) {
+      if (++i == argc) APPERR ("argument to '-e' missing");
+      else if (extension_path)
+        APPERR ("multiple extension file options '-e %s' and '-e %s'",
+          extension_path, argv[i]);
+      else if (!force_writing &&
+               most_likely_existing_cnf_file (argv[i]))
+        APPERR ("extension file '%s' most likely existing CNF (use '-f')",
+                argv[i]);
+      else if (!File::writable (argv[i]))
+        APPERR ("extension file '%s' not writable", argv[i]);
+      else extension_path = argv[i];
+    } else if (is_color_option (argv[i])) {
+      tout.force_colors ();
+      terr.force_colors ();
+    } else if (is_no_color_option (argv[i])) {
+      tout.force_no_colors ();
+      terr.force_no_colors ();
+    } else if (!strcmp (argv[i], "--witness") ||
+               !strcmp (argv[i], "--witness=true") ||
+               !strcmp (argv[i], "--witness=1"))
+      witness = true;
+    else if (!strcmp (argv[i], "-n") ||
+             !strcmp (argv[i], "--no-witness") ||
+             !strcmp (argv[i], "--witness=false") ||
+             !strcmp (argv[i], "--witness=0"))
+      witness = false;
+    else if (!strcmp (argv[i], "--less")) {             // EXPERIMENTAL!
+      if (less) APPERR ("multiple '--less' options");
+      else if (!isatty (1))
+        APPERR ("'--less' without '<stdout>' connected to terminal");
+      else less = true;
+    } else if (!strcmp (argv[i], "-c")) {
+      if (++i == argc) APPERR ("argument to '-c' missing");
+      else if (conflict_limit_specified)
+        APPERR ("multiple conflict limits '-c %s' and '-c %s'",
+          conflict_limit_specified, argv[i]);
+      else if (!parse_int_str (argv[i], conflict_limit))
+        APPERR ("invalid argument in '-c %s'", argv[i]);
+      else if (conflict_limit < 0)
+        APPERR ("invalid conflict limit");
+      else conflict_limit_specified = argv[i];
+    } else if (!strcmp (argv[i], "-d")) {
+      if (++i == argc) APPERR ("argument to '-d' missing");
+      else if (decision_limit_specified)
+        APPERR ("multiple decision limits '-d %s' and '-d %s'",
+          decision_limit_specified, argv[i]);
+      else if (!parse_int_str (argv[i], decision_limit))
+        APPERR ("invalid argument in '-d %s'", argv[i]);
+      else if (decision_limit < 0)
+        APPERR ("invalid decision limit");
+      else decision_limit_specified = argv[i];
+    }
+#ifndef __WIN32
+    else if (!strcmp (argv[i], "-t")) {
+      if (++i == argc) APPERR ("argument to '-t' missing");
+      else if (time_limit_specified)
+        APPERR ("multiple time limit '-t %s' and '-t %s'",
+          time_limit_specified, argv[i]);
+      else if (!parse_int_str (argv[i], time_limit))
+        APPERR ("invalid argument in '-d %s'", argv[i]);
+      else if (time_limit < 0)
+        APPERR ("invalid time limit");
+      else time_limit_specified = argv[i];
+    }
+#endif
+#ifndef QUIET
+    else if (!strcmp (argv[i], "-q")) set ("--quiet");
+    else if (!strcmp (argv[i], "-v"))
+      set ("verbose", get ("verbose") + 1);
+#endif
+#ifdef LOGGING
+    else if (!strcmp (argv[i], "-l")) set ("--log");
+#endif
+    else if (!strcmp (argv[i], "-f") ||
+             !strcmp (argv[i], "--force") ||
+             !strcmp (argv[i], "--force=1") ||
+             !strcmp (argv[i], "--force=true"))
+      force_strict_parsing = 0,
+      force_writing = true;
+    else if (!strcmp (argv[i], "--strict") ||
+             !strcmp (argv[i], "--strict=1") ||
+             !strcmp (argv[i], "--strict=true"))
+      force_strict_parsing = 2;
+    else if (has_prefix (argv[i], "-O")) {
+      if (optimization_specified)
+        APPERR ("multiple optimization options '%s' and '%s'",
+          optimization_specified, argv[i]);
+      optimization_specified = argv[i];
+      if (!parse_int_str (argv[i] + 2, optimize))
+        APPERR ("invalid optimization option '%s'", argv[i]);
+      if (optimize < 0 || optimize > 31)
+        APPERR ("invalid argument in '%s' (expected '0..31')", argv[i]);
+    } else if (has_prefix (argv[i], "-P")) {
+      if (preprocessing_specified)
+        APPERR ("multiple preprocessing options '%s' and '%s'",
+          preprocessing_specified, argv[i]);
+      preprocessing_specified = argv[i];
+      if (!parse_int_str (argv[i] + 2, preprocessing))
+        APPERR ("invalid preprocessing option '%s'", argv[i]);
+      if (preprocessing < 0)
+        APPERR ("invalid argument in '%s' (expected non-negative number)",
+          argv[i]);
+    } else if (has_prefix (argv[i], "-L")) {
+      if (localsearch_specified)
+        APPERR ("multiple local search options '%s' and '%s'",
+          localsearch_specified, argv[i]);
+      localsearch_specified = argv[i];
+      if (!parse_int_str (argv[i] + 2, localsearch))
+        APPERR ("invalid local search option '%s'", argv[i]);
+      if (localsearch < 0)
+        APPERR ("invalid argument in '%s' (expected non-negative number)",
+          argv[i]);
+    } else if (has_prefix (argv[i], "--") &&
+               solver->is_valid_configuration (argv[i] + 2)) {
+      solver->configure (argv[i] + 2);
+    } else if (set (argv[i])) {
+      /* nothing do be done */
+    } else if (argv[i][0] == '-') APPERR ("invalid option '%s'", argv[i]);
+    else if (proof_specified) APPERR ("too many arguments");
+    else if (dimacs_specified) {
+      proof_path = argv[i];
+      proof_specified = true;
+      if (!force_writing &&
+          most_likely_existing_cnf_file (proof_path))
+        APPERR ("DRAT proof file '%s' most likely existing CNF (use '-f')",
+          proof_path);
+      else if (!File::writable (proof_path))
+        APPERR ("DRAT proof file '%s' not writable", proof_path);
+    } else dimacs_specified = true, dimacs_path = argv[i];
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  if (dimacs_specified && dimacs_path && !File::exists (dimacs_path))
+    APPERR ("DIMACS input file '%s' does not exist", dimacs_path);
+  if (read_solution_path && !File::exists (read_solution_path))
+    APPERR ("solution file '%s' does not exist", read_solution_path);
+  if (dimacs_specified && dimacs_path &&
+      proof_specified && proof_path &&
+      !strcmp (dimacs_path, proof_path) && strcmp (dimacs_path, "-"))
+    APPERR ("DIMACS input file '%s' also specified as DRAT proof file",
+      dimacs_path);
+
+  /*----------------------------------------------------------------------*/
+  // The '--less' option is not fully functional yet (it is also not
+  // mentioned in the 'usage' message yet).  It only works as expected if
+  // you let the solver run until it exits.  The goal is to have a similar
+  // experience as with 'git diff' if the terminal is too small for the
+  // printed messages, but this needs substantial hacking.
+  //
+  // TODO: add proper forking, waiting, signal catching & propagating ...
+  //
+  FILE * less_pipe;
+  if (less) {
+    assert (isatty (1));
+    less_pipe = popen ("less -r", "w");
+    if (!less_pipe)
+      APPERR ("could not execute and open pipe to 'less -r' command");
+    dup2 (fileno (less_pipe), 1);
+  } else less_pipe = 0;
+
+  /*----------------------------------------------------------------------*/
+
+  if (read_solution_path && !get ("check")) set ("--check");
+#ifndef QUIET
+  if (!get ("quiet")) {
+    solver->section ("banner");
+    solver->message ("%sCaDiCaL Radically Simplified CDCL SAT Solver%s",
+      tout.bright_magenta_code (), tout.normal_code ());
+    solver->message ("%s%s%s",
+      tout.bright_magenta_code (), copyright (), tout.normal_code ());
+    solver->message ();
+    CaDiCaL::Solver::build (stdout, "c ");
+  }
+#endif
+  if (preprocessing > 0 || localsearch > 0 ||
+#ifndef __WIN32
+      time_limit >= 0 || 
+#endif
+      conflict_limit >= 0 || decision_limit >= 0) {
+    solver->section ("limit");
+    if (preprocessing > 0) {
+      solver->message (
+        "enabling %d initial rounds of preprocessing (due to '%s')",
+        preprocessing, preprocessing_specified);
+      solver->limit ("preprocessing", preprocessing);
+    }
+    if (localsearch > 0) {
+      solver->message (
+        "enabling %d initial rounds of local search (due to '%s')",
+        localsearch, localsearch_specified);
+      solver->limit ("localsearch", localsearch);
+    }
+#ifndef __WIN32
+    if (time_limit >= 0) {
+      solver->message (
+        "setting time limit to %d seconds real time (due to '-t %s')",
+        time_limit, time_limit_specified);
+      Signal::alarm (time_limit);
+      solver->connect_terminator (this);
+    }
+#endif
+    if (conflict_limit >= 0) {
+      solver->message (
+        "setting conflict limit to %d conflicts (due to '%s')",
+        conflict_limit, conflict_limit_specified);
+      bool succeeded = solver->limit ("conflicts", conflict_limit);
+      assert (succeeded), (void) succeeded;
+    }
+    if (decision_limit >= 0) {
+      solver->message (
+        "setting decision limit to %d decisions (due to '%s')",
+        decision_limit, decision_limit_specified);
+      bool succeeded = solver->limit ("decisions", decision_limit);
+      assert (succeeded), (void) succeeded;
+    }
+  }
+  if (verbose () || proof_specified) solver->section ("proof tracing");
+  if (proof_specified) {
+    if (!proof_path) {
+      const bool force_binary = (isatty (1) && get ("binary"));
+      if (force_binary) set ("--no-binary");
+      solver->message ("writing %s proof trace to %s'<stdout>'%s",
+        (get ("binary") ? "binary" : "non-binary"),
+        tout.green_code (), tout.normal_code ());
+      if (force_binary)
+        solver->message (
+          "connected to terminal thus non-binary proof forced");
+      solver->trace_proof (stdout, "<stdout>");
+    } else if (!solver->trace_proof (proof_path))
+      APPERR ("can not open and write DRAT proof to '%s'", proof_path);
+    else
+      solver->message (
+        "writing %s proof trace to %s'%s'%s",
+        (get ("binary") ? "binary" : "non-binary"),
+        tout.green_code (), proof_path, tout.normal_code ());
+  } else solver->verbose (1, "will not generate nor write DRAT proof");
+  solver->section ("parsing input");
+  dimacs_name = dimacs_path ? dimacs_path : "<stdin>";
+  string help;
+  if (!dimacs_path) {
+    help += " ";
+    help += tout.magenta_code ();
+    help += "(use '-h' for a list of common options)";
+    help += tout.normal_code ();
+  }
+  solver->message ("reading DIMACS file from %s'%s'%s%s",
+    tout.green_code (), dimacs_name, tout.normal_code (), help.c_str ());
+  bool incremental;
+  vector<int> cube_literals;
+  if (dimacs_path)
+    err = solver->read_dimacs(dimacs_path, max_var, force_strict_parsing,
+                            incremental, cube_literals);
+  else
+    err = solver->read_dimacs(stdin, dimacs_name, max_var, force_strict_parsing,
+                            incremental, cube_literals);
+  if (err) APPERR ("%s", err);
+  if (read_solution_path) {
+    solver->section ("parsing solution");
+    solver->message ("reading solution file from '%s'", read_solution_path);
+    if ((err = solver->read_solution (read_solution_path)))
+      APPERR ("%s", err);
+  }
+
+  solver->section ("options");
+  if (optimize > 0) {
+    solver->optimize (optimize);
+    solver->message ();
+  }
+  solver->options ();
+
+  int res = 0;
+
+  if (incremental) {
+    bool reporting = get ("report") > 1 || get ("verbose") > 0;
+    if (!reporting) set ("report", 0);
+    if (!reporting) solver->section ("incremental solving");
+    size_t cubes = 0, solved = 0;
+    size_t satisfiable = 0, unsatisfiable = 0, inconclusive = 0;
+#ifndef QUIET
+    bool quiet = get ("quiet");
+    struct { double start, delta, sum; } time = { 0, 0, 0 };
+#endif
+    for (auto lit : cube_literals)
+      if (!lit)
+        cubes++;
+    if (!reporting) {
+    if (cubes)
+      solver->message ("starting to solve %zu cubes", cubes),
+      solver->message ();
+    else
+      solver->message ("no cube to solve");
+    }
+    vector<int> cube, failed;
+    for (auto lit : cube_literals) {
+      if (lit) cube.push_back (lit);
+      else {
+        reverse (cube.begin (), cube.end ());
+        for (auto other : cube)
+          solver->assume (other);
+        if (solved++) {
+          if (conflict_limit >= 0)
+            (void) solver->limit ("conflicts", conflict_limit);
+          if (decision_limit >= 0)
+            (void) solver->limit ("decisions", decision_limit);
+        }
+#ifndef QUIET
+        char buffer[160];
+        if (!quiet) {
+          if (reporting) {
+            sprintf (buffer, "solving cube %zu / %zu %.0f%%",
+               solved, cubes, percent (solved, cubes));
+            solver->section (buffer);
+          }
+          time.start = absolute_process_time ();
+        }
+#endif
+        res = solver->solve ();
+#ifndef QUIET
+        if (!quiet) {
+          time.delta = absolute_process_time () - time.start;
+          time.sum += time.delta;
+          sprintf (buffer,
+            "%s"
+            "in %.3f sec "
+            "(%.0f%% after %.2f sec at %.0f ms/cube)"
+            "%s",
+            tout.magenta_code (),
+            time.delta,
+            percent (solved, cubes),
+            time.sum,
+            relative (1e3*time.sum, solved),
+            tout.normal_code ());
+          if (reporting)
+            solver->message ();
+          const char * cube_str, * status_str, * color_code;
+          if (res == 10) {
+            cube_str = "CUBE";
+            color_code = tout.green_code ();
+            status_str = "SATISFIABLE";
+          } else if (res == 20) {
+            cube_str = "CUBE";
+            color_code = tout.cyan_code ();
+            status_str = "UNSATISFIABLE";
+          } else {
+            cube_str = "cube";
+            color_code = tout.magenta_code ();
+            status_str = "inconclusive";
+          }
+          const char * fmt;
+          if (reporting) fmt = "%s%s %zu %s%s %s";
+          else           fmt = "%s%s %zu %-13s%s %s";
+          solver->message (fmt,
+            color_code, cube_str, solved, status_str,
+            tout.normal_code (), buffer);
+        }
+#endif
+        if (res == 10) {
+          satisfiable++;
+          break;
+        } else if (res == 20) {
+          unsatisfiable++;
+          for (auto other : cube)
+            if (solver->failed (other))
+              failed.push_back (other);
+          for (auto other : failed)
+            solver->add (-other);
+          solver->add (0);
+          failed.clear ();
+        } else {
+          assert (!res);
+          inconclusive++;
+          if (timesup)
+            break;
+        }
+        cube.clear ();
+      }
+    }
+    solver->section ("incremental summary");
+    solver->message ("%zu cubes solved %.0f%%",
+      solved, percent (solved, cubes));
+    solver->message ("%zu cubes inconclusive %.0f%%",
+      inconclusive, percent (inconclusive, solved));
+    solver->message ("%zu cubes unsatisfiable %.0f%%",
+      unsatisfiable, percent (unsatisfiable, solved));
+    solver->message ("%zu cubes satisfiable %.0f%%",
+      satisfiable, percent (satisfiable, solved));
+
+    if (inconclusive && res == 20)
+      res = 0;
+  } else {
+    solver->section ("solving");
+    res = solver->solve ();
+  }
+
+  if (proof_specified) {
+    solver->section ("closing proof");
+    solver->flush_proof_trace ();
+    solver->close_proof_trace ();
+  }
+
+  if (output_path) {
+    solver->section ("writing output");
+    solver->message ("writing simplified CNF to DIMACS file %s'%s'%s",
+      tout.green_code (), output_path, tout.normal_code ());
+    err = solver->write_dimacs (output_path, max_var);
+    if (err) APPERR ("%s", err);
+  }
+
+  if (extension_path) {
+    solver->section ("writing extension");
+    solver->message ("writing extension stack to %s'%s'%s",
+      tout.green_code (), extension_path, tout.normal_code ());
+    err = solver->write_extension (extension_path);
+    if (err) APPERR ("%s", err);
+  }
+
+  solver->section ("result");
+
+  FILE * write_result_file = stdout;
+  if (write_result_path)
+    {
+      write_result_file = fopen (write_result_path, "w");
+      if (!write_result_file)
+        APPERR ("could not write solution to '%s'", write_result_path);
+      solver->message ("writing result to '%s'", write_result_path);
+    }
+
+  if (res == 10) {
+    fputs ("s SATISFIABLE\n", write_result_file);
+    if (witness)
+      print_witness (write_result_file);
+  } else if (res == 20) fputs ("s UNSATISFIABLE\n", write_result_file);
+  else fputs ("c UNKNOWN\n", write_result_file);
+  fflush (write_result_file);
+  if (write_result_path)
+    fclose (write_result_file);
+  solver->statistics ();
+  solver->resources ();
+  solver->section ("shutting down");
+  solver->message ("exit %d", res);
+  if (less_pipe) {
+    close (1);
+    pclose (less_pipe);
+  }
+#ifndef __WIN32
+  if (time_limit > 0)
+    alarm (0);
+#endif
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The real initialization is delayed.
+
+void App::init () {
+
+  assert (!solver);
+
+#ifndef __WIN32
+  time_limit = -1;
+#endif
+  force_strict_parsing = 1;
+  force_writing = false;
+  max_var = 0;
+  timesup = false;
+
+  // Call 'new Solver' only after setting 'reportdefault' and do not
+  // add this call to the member initialization above. This is because for
+  // stand-alone usage the default report default value is 'true' while for
+  // library usage it should remain 'false'.  See the explanation in
+  // 'options.hpp' related to 'reportdefault' for details.
+
+  CaDiCaL::Options::reportdefault = 1;
+  solver = new Solver ();
+  Signal::set (this);
+}
+
+/*------------------------------------------------------------------------*/
+
+App::App () : solver (0) { }      // Only partially initialize the app.
+
+App::~App () {
+  if (!solver) return;            // Only partially initialized.
+  Signal::reset ();
+  delete solver;
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifndef QUIET
+
+void App::signal_message (const char * msg, int sig) {
+  solver->message (
+    "%s%s %ssignal %d%s (%s)%s",
+    tout.red_code (), msg,
+    tout.bright_red_code (), sig,
+    tout.red_code (), Signal::name (sig),
+    tout.normal_code ());
+}
+
+#endif
+
+void App::catch_signal (int sig) {
+#ifndef QUIET
+  if (!get ("quiet")) {
+    solver->message ();
+    signal_message ("caught", sig);
+    solver->section ("result");
+    solver->message ("UNKNOWN");
+    solver->statistics ();
+    solver->resources ();
+    solver->message ();
+    signal_message ("raising", sig);
+  }
+#else
+  (void) sig;
+#endif
+}
+
+void App::catch_alarm () {
+  // Both approaches work. We keep them here for illustration purposes.
+#if 0 // THIS IS AN ALTERNATIVE WE WANT TO KEEP AROUND.
+  solver->terminate (); // Immediate asynchronous call into solver.
+#else
+  timesup = true;       // Wait for solver to call 'App::terminate ()'.
+#endif
+}
+
+} // end of 'namespace CaDiCaL'
+
+/*------------------------------------------------------------------------*/
+
+// The actual app is allocated on the stack and then its 'main' function is
+// called.  This looks like that there are no static variables, which is not
+// completely true, since both the signal handler connected to the app as
+// well as the terminal have statically allocated components as well as the
+// options table 'Options::table'.  All are shared among solvers.
+
+int main (int argc, char ** argv) {
+  CaDiCaL::App app;
+  int res = app.main (argc, argv);
+  return res;
+}
diff --git a/hCaD_V2/src/cadical.hpp b/hCaD_V2/src/cadical.hpp
new file mode 100644
index 0000000..cbb064b
--- /dev/null
+++ b/hCaD_V2/src/cadical.hpp
@@ -0,0 +1,891 @@
+#ifndef _cadical_hpp_INCLUDED
+#define _cadical_hpp_INCLUDED
+
+#include <cstdio>
+#include <cstdint>
+#include <vector>
+
+namespace CaDiCaL {
+
+/*========================================================================*/
+
+// This provides the actual API of the CaDiCaL solver, which is implemented
+// in the class 'Solver' below.  Beside its constructor and destructor most
+// important is the IPASIR part which you can find between 'BEGIN IPASIR'
+// and 'END IPASIR' comments below.  The following '[Example]' below might
+// also be a good starting point to understand the API.
+
+/*========================================================================*/
+
+// [Example]
+//
+// The internal solver state follows the IPASIR API model used in the
+// incremental track of the SAT competition.  State transitions are
+// triggered by member function calls, declared and described below.
+//
+// Consider the following code (from 'test/api/example.cpp') of API usage:
+//
+//   CaDiCaL::Solver * solver = new CaDiCaL::Solver;
+//
+//   // ------------------------------------------------------------------
+//   // Encode Problem and check without assumptions.
+//
+//   enum { TIE = 1, SHIRT = 2 };
+//
+//   solver->add (-TIE), solver->add (SHIRT),  solver->add (0);
+//   solver->add (TIE),  solver->add (SHIRT),  solver->add (0);
+//   solver->add (-TIE), solver->add (-SHIRT), solver->add (0);
+//
+//   int res = solver->solve ();    // Solve instance.
+//   assert (res == 10);            // Check it is 'SATISFIABLE'.
+//
+//   res = solver->val (TIE);       // Obtain assignment of 'TIE'.
+//   assert (res < 0);              // Check 'TIE' assigned to 'false'.
+//
+//   res = solver->val (SHIRT);     // Obtain assignment of 'SHIRT'.
+//   assert (res > 0);              // Check 'SHIRT' assigned to 'true'.
+//
+//   // ------------------------------------------------------------------
+//   // Incrementally solve again under one assumption.
+//
+//   solver->assume (TIE);          // Now force 'TIE' to true.
+//
+//   res = solver->solve ();        // Solve again incrementally.
+//   assert (res == 20);            // Check it is 'UNSATISFIABLE'.
+//
+//   res = solver->failed (TIE);    // Check 'TIE' responsible.
+//   assert (res);                  // Yes, 'TIE' in core.
+//
+//   res = solver->failed (SHIRT);  // Check 'SHIRT' responsible.
+//   assert (!res);                 // No, 'SHIRT' not in core.
+//
+//   // ------------------------------------------------------------------
+//   // Incrementally solve once more under another assumption.
+//
+//   solver->assume (-SHIRT);       // Now force 'SHIRT' to false.
+//
+//   res = solver->solve ();        // Solve again incrementally.
+//   assert (res == 20);            // Check it is 'UNSATISFIABLE'.
+//
+//   res = solver->failed (TIE);    // Check 'TIE' responsible.
+//   assert (!res);                 // No, 'TIE' not in core.
+//
+//   res = solver->failed (-SHIRT); // Check '!SHIRT' responsible.
+//   assert (res);                  // Yes, '!SHIRT' in core.
+//
+//   // ------------------------------------------------------------------
+//
+//   delete solver;
+
+/*========================================================================*/
+
+// [States and Transitions]
+//
+// Compared to IPASIR we also use an 'ADDING' state in which the solver
+// stays while adding non-zero literals until the clause is completed
+// through adding a zero literal.  The additional 'INITIALIZING',
+// 'CONFIGURING' and 'DELETING' states are also not part of IPASIR but also
+// useful for testing and debugging.
+//
+// We have the following transitions which are all synchronous except for
+// the reentrant 'terminate' call:
+//
+//                         new
+// INITIALIZING --------------------------> CONFIGURING
+//
+//                    set / trace
+//  CONFIGURING --------------------------> CONFIGURING
+//
+//               add (non zero literal)
+//        VALID --------------------------> ADDING
+//
+//               add (zero literal)
+//        VALID --------------------------> UNKNOWN
+//
+//               assume (non zero literal)
+//        READY --------------------------> UNKNOWN
+//
+//                        solve
+//        READY --------------------------> SOLVING
+//
+//                     (internal)
+//      SOLVING --------------------------> READY
+//
+//                val (non zero literal)
+//    SATISFIED --------------------------> SATISFIED
+//
+//               failed (non zero literal )
+//  UNSATISFIED --------------------------> UNSATISFIED
+//
+//                        delete
+//        VALID --------------------------> DELETING
+//
+// where
+//
+//        READY = CONFIGURING  | UNKNOWN | SATISFIED | UNSATISFIED
+//        VALID = READY        | ADDING
+//      INVALID = INITIALIZING | DELETING
+//
+// The 'SOLVING' state is only visible in different contexts, i.e., from
+// another thread or from a signal handler.  It is used to implement
+// 'terminate'.  Here is the only asynchronous transition:
+//
+//               terminate (asynchronously)
+//      SOLVING  ------------------------->  UNKNOWN
+//
+// The important behaviour to remember is that adding or assuming a literal
+// (immediately) destroys the satisfying assignment in the 'SATISFIED' state
+// and vice versa resets all assumptions in the 'UNSATISFIED' state.  This
+// is exactly the behaviour required by the IPASIR interface.
+//
+// Furthermore, the model can only be queried through 'val' in the
+// 'SATISFIED' state, while extracting failed assumptions with 'val' only in
+// the 'UNSATISFIED' state.  Solving can only be started in the 'UNKNOWN' or
+// 'CONFIGURING' state or after the previous call to 'solve' yielded an
+// 'UNKNOWN, 'SATISFIED' or 'UNSATISFIED' state.
+//
+// All literals have to be valid literals too, i.e., 32-bit integers
+// different from 'INT_MIN'.  If any of these requirements is violated the
+// solver aborts with an 'API contract violation' message.
+//
+// HINT: If you do not understand why a contract is violated you can run
+// 'mobical' on the failing API call trace.  Point the environment variable
+// 'CADICAL_API_TRACE' to the file where you want to save the trace during
+// execution of your program linking against the library.  You probably need
+// for 'mobical' to use the option '--do-not-enforce-contracts' though to
+// force running into the same contract violation.
+//
+// Additional API calls (like 'freeze' and 'melt') do not change the state
+// of the solver and are all described below.
+
+/*========================================================================*/
+
+// States are represented by a bit-set in order to combine them.
+
+enum State
+{
+  INITIALIZING = 1,             // during initialization (invalid)
+  CONFIGURING  = 2,             // configure options (with 'set')
+  UNKNOWN      = 4,             // ready to call 'solve'
+  ADDING       = 8,             // adding clause literals (zero missing)
+  SOLVING      = 16,            // while solving (within 'solve')
+  SATISFIED    = 32,            // satisfiable allows 'val'
+  UNSATISFIED  = 64,            // unsatisfiable allows 'failed'
+  DELETING     = 128,           // during and after deletion (invalid)
+
+  // These combined states are used to check contracts.
+
+  READY   = CONFIGURING  | UNKNOWN | SATISFIED | UNSATISFIED,
+  VALID   = READY        | ADDING,
+  INVALID = INITIALIZING | DELETING
+};
+
+/*------------------------------------------------------------------------*/
+
+// Opaque classes needed in the API and declared in the same namespace.
+
+class File;
+struct Internal;
+struct External;
+
+/*------------------------------------------------------------------------*/
+
+// Forward declaration of call-back classes. See bottom of this file.
+
+class Learner;
+class Terminator;
+class ClauseIterator;
+class WitnessIterator;
+
+/*------------------------------------------------------------------------*/
+
+class Solver {
+
+public:
+
+  // ====== BEGIN IPASIR ===================================================
+
+  // This section implements the corresponding IPASIR functionality.
+
+  Solver ();
+  ~Solver ();
+
+  static const char * signature ();     // name of this library
+
+  // Core functionality as in the IPASIR incremental SAT solver interface.
+  // (recall 'READY = CONFIGURING | UNKNOWN | SATISFIED | UNSATISFIED').
+  // Further note that 'lit' is required to be different from 'INT_MIN' and
+  // different from '0' except for 'add'.
+
+  // Add valid literal to clause or zero to terminate clause.
+  //
+  //   require (VALID)                  // recall 'VALID = READY | ADDING'
+  //   if (lit) ensure (ADDING)         // and thus VALID but not READY
+  //   if (!lit) ensure (UNKNOWN)       // and thus READY
+  //
+  void add (int lit);
+
+  // Assume valid non zero literal for next call to 'solve'.  These
+  // assumptions are reset after the call to 'solve' as well as after
+  // returning from 'simplify' and 'lookahead.
+  //
+  //   require (READY)
+  //   ensure (UNKNOWN)
+  //
+  void assume (int lit);
+
+  // Try to solve the current formula.  Returns
+  //
+  //    0 = UNSOLVED     (limit reached or interrupted through 'terminate')
+  //   10 = SATISFIABLE
+  //   20 = UNSATISFIABLE
+  //
+  //   require (READY)
+  //   ensure (UNKNOWN | SATISFIED | UNSATISFIED)
+  //
+  // Note, that while in this call the solver actually transitions to state
+  // 'SOLVING', which however is only visible from a different context,
+  // i.e., from a different thread or from a signal handler.  Only right
+  // before returning from this call it goes into a 'READY' state.
+  //
+  int solve ();
+
+  // Get value (-lit=false, lit=true) of valid non-zero literal.
+  //
+  //   require (SATISFIED)
+  //   ensure (SATISFIED)
+  //
+  int val (int lit);
+
+  // Determine whether the valid non-zero literal is in the core.
+  // Returns 'true' if the literal is in the core and 'false' otherwise.
+  // Note that the core does not have to be minimal.
+  //
+  //   require (UNSATISFIED)
+  //   ensure (UNSATISFIED)
+  //
+  bool failed (int lit);
+
+  // Add call-back which is checked regularly for termination.  There can
+  // only be one terminator connected.  If a second (non-zero) one is added
+  // the first one is implicitly disconnected.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void connect_terminator (Terminator * terminator);
+  void disconnect_terminator ();
+
+  // Add call-back which allows to export learned clauses.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void connect_learner (Learner * learner);
+  void disconnect_learner ();
+
+  // ====== END IPASIR =====================================================
+
+  //------------------------------------------------------------------------
+  // This function determines a good splitting literal.  The result can be
+  // zero if the formula is proven to be satisfiable or unsatisfiable.  This
+  // can then be checked by 'state ()'.  If the formula is empty and
+  // the function is not able to determine satisfiability also zero is
+  // returned but the state remains unknown.
+  //
+  //   require (READY)
+  //   ensure (UNKNOWN|SATISFIED|UNSATISFIED)
+  //
+  int lookahead(void);
+
+  struct CubesWithStatus {
+    int status;
+    std::vector<std::vector<int>> cubes;
+  };
+
+  CubesWithStatus generate_cubes(int, int min_depth = 0);
+
+  void reset_assumptions();
+
+  // Return the current state of the solver as defined above.
+  //
+  const State & state () const { return _state; }
+
+  // Similar to 'state ()' but using the staddard competition exit codes of
+  // '10' for 'SATISFIABLE', '20' for 'UNSATISFIABLE' and '0' otherwise.
+  //
+  int status () const {
+         if (_state == SATISFIED)   return 10;
+    else if (_state == UNSATISFIED) return 20;
+    else                            return 0;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  static const char * version ();    // return version string
+
+  /*----------------------------------------------------------------------*/
+  // Copy 'this' into a fresh 'other'.  The copy procedure is not a deep
+  // clone, but only copies irredundant clauses and units.  It also makes
+  // sure that witness reconstruction works with the copy as with the
+  // original formula such that both solvers have the same models.
+  // Assumptions are not copied.  Options however are copied as well as
+  // flags which remember the current state of variables in preprocessing.
+  //
+  //   require (READY)          // for 'this'
+  //   ensure (READY)           // for 'this'
+  //
+  //   other.require (CONFIGURING)
+  //   other.ensure (CONFIGURING | UNKNOWN)
+  //
+  void copy (Solver & other) const;
+
+  /*----------------------------------------------------------------------*/
+  // Variables are usually added and initialized implicitly whenever a
+  // literal is used as an argument except for the functions 'val', 'fixed',
+  // 'failed' and 'frozen'.  However, the library internally keeps a maximum
+  // variable index, which can be queried.
+  //
+  //   require (VALID | SOLVING)
+  //   ensure (VALID | SOLVING)
+  //
+  int vars ();
+
+  // Increase the maximum variable index explicitly.  This function makes
+  // sure that at least 'min_max_var' variables are initialized.  Since it
+  // might need to reallocate tables, it destroys a satisfying assignment
+  // and has the same state transition and conditions as 'assume' etc.
+  //
+  //   require (READY)
+  //   ensure (UNKNOWN)
+  //
+  void reserve (int min_max_var);
+
+#ifndef NTRACING
+  //------------------------------------------------------------------------
+  // This function can be used to write API calls to a file.  The same
+  // format is used which 'mobical' can read, execute and also shrink
+  // through delta debugging.
+  //
+  // Tracing API calls can also be achieved by using the environment
+  // variable 'CADICAL_API_TRACE'.  That alternative is useful if you do not
+  // want to change the source code using the solver, e.g., if you only have
+  // a binary with the solver linked in.  However, that method only allows
+  // to trace one solver instance, while with the following function API
+  // tracing can be enabled for different solver instances individually.
+  //
+  // The solver will flush the file after every trace API call but does not
+  // close it during deletion. It remains owned by the user of the library.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void trace_api_calls (FILE * file);
+#endif
+
+  //------------------------------------------------------------------------
+  // Option handling.
+
+  // Determine whether 'name' is a valid option name.
+  //
+  static bool is_valid_option (const char * name);
+
+  // Determine whether 'name' enables a specific preprocessing technique.
+  //
+  static bool is_preprocessing_option (const char * name);
+
+  // Determine whether 'arg' is a valid long option of the form '--<name>',
+  // '--<name>=<val>' or '--no-<name>' similar to 'set_long_option' below.
+  // Legal values are 'true', 'false', or '[-]<mantissa>[e<exponent>]'.
+
+  static bool is_valid_long_option (const char * arg);
+
+  // Get the current value of the option 'name'.  If 'name' is invalid then
+  // zero is returned.  Here '--...' arguments as invalid options.
+  //
+  int get (const char * name);
+
+  // Set the default verbose message prefix (default "c ").
+  //
+  void prefix (const char * verbose_message_prefix);
+
+  // Explicit version of setting an option.  If the option '<name>' exists
+  // and '<val>' can be parsed then 'true' is returned.  If the option value
+  // is out of range the actual value is computed as the closest (minimum or
+  // maximum) value possible, but still 'true' is returned.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  // Thus options can only bet set right after initialization.
+  //
+  bool set (const char * name, int val);
+
+  // This function accepts options in command line syntax:
+  //
+  //   '--<name>=<val>', '--<name>', or '--no-<name>'
+  //
+  // It actually calls the previous 'set' function after parsing 'arg'.  The
+  // same values are expected as for 'is_valid_long_option' above and as
+  // with 'set' any value outside of the range of legal values for a
+  // particular option are set to either the minimum or maximum depending on
+  // which side of the valid interval they lie.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  bool set_long_option (const char * arg);
+
+  // Determine whether 'name' is a valid configuration.
+  //
+  static bool is_valid_configuration (const char *);
+
+  // Overwrite (some) options with the forced values of the configuration.
+  // The result is 'true' iff the 'name' is a valid configuration.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  bool configure (const char *);
+
+  // Increase preprocessing and inprocessing limits by '10^<val>'.  Values
+  // below '0' are ignored and values above '9' are reduced to '9'.
+  //
+  //   require (READY)
+  //   ensure (READY)
+  //
+  void optimize (int val);
+
+  // Specify search limits, where currently 'name' can be "conflicts",
+  // "decisions", "preprocessing", or "localsearch".  The first two limits
+  // are unbounded by default.  Thus using a negative limit for conflicts or
+  // decisions switches back to the default of unlimited search (for that
+  // particular limit).  The preprocessing limit determines the number of
+  // preprocessing rounds, which is zero by default.  Similarly, the local
+  // search limit determines the number of local search rounds (also zero by
+  // default).  As with 'set', the return value denotes whether the limit
+  // 'name' is valid.  These limits are only valid for the next 'solve' or
+  // 'simplify' call and reset to their default after 'solve' returns (as
+  // well as overwritten and reset during calls to 'simplify' and
+  // 'lookahead').  We actually also have an internal "terminate" limit
+  // which however should only be used for testing and debugging.
+  //
+  //   require (READY)
+  //   ensure (READY)
+  //
+  bool limit (const char * arg, int val);
+  bool is_valid_limit (const char * arg);
+
+  // The number of currently active variables and clauses can be queried by
+  // these functions.  Variables become active if a clause is added with it.
+  // They become inactive if they are eliminated or fixed at the root level
+  // Clauses become inactive if they are satisfied, subsumed, eliminated.
+  // Redundant clauses are reduced regularly and thus the 'redundant'
+  // function is less useful.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  int active () const;          // Number of active variables.
+  int64_t redundant () const;   // Number of active redundant clauses.
+  int64_t irredundant () const; // Number of active irredundant clauses.
+
+  //------------------------------------------------------------------------
+  // This function executes the given number of preprocessing rounds. It is
+  // similar to 'solve' with 'limits ("preprocessing", rounds)' except that
+  // no CDCL nor local search, nor lucky phases are executed.  The result
+  // values are also the same: 0=unknown, 10=satisfiable, 20=unsatisfiable.
+  // As 'solve' it resets current assumptions and limits before returning.
+  // The numbers of rounds should not be negative.  If the number of rounds
+  // is zero only clauses are restored (if necessary) and top level unit
+  // propagation is performed, which both take some time.
+  //
+  //   require (READY)
+  //   ensure (UNKNOWN | SATISFIED | UNSATISFIED)
+  //
+  int simplify (int rounds = 3);
+
+  //------------------------------------------------------------------------
+  // Force termination of 'solve' asynchronously.
+  //
+  //  require (SOLVING | READY)
+  //  ensure (UNKNOWN)           // actually not immediately (synchronously)
+  //
+  void terminate ();
+
+  //------------------------------------------------------------------------
+
+  // We have the following common reference counting functions, which avoid
+  // to restore clauses but require substantial user guidance.  This was the
+  // only way to use inprocessing in incremental SAT solving in Lingeling
+  // (and before in MiniSAT's 'freeze' / 'thaw') and which did not use
+  // automatic clause restoring.  In general this is slower than
+  // restoring clauses and should not be used.
+  //
+  // In essence the user freezes variables which potentially are still
+  // needed in clauses added or assumptions used after the next 'solve'
+  // call.  As in Lingeling you can freeze a variable multiple times, but
+  // then have to melt it the same number of times again in order to enable
+  // variable eliminating on it etc.  The arguments can be literals
+  // (negative indices) but conceptually variables are frozen.
+  //
+  // In the old way of doing things without restore you should not use a
+  // variable incrementally (in 'add' or 'assume'), which was used before
+  // and potentially could have been eliminated in a previous 'solve' call.
+  // This can lead to spurious satisfying assignment.  In order to check
+  // this API contract one can use the 'checkfrozen' option.  This has the
+  // drawback that restoring clauses implicitly would fail with a fatal
+  // error message even if in principle the solver could just restore
+  // clauses. Thus this option is disabled by default.
+  //
+  // See our SAT'19 paper [FazekasBiereScholl-SAT'19] for more details.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  bool frozen (int lit) const;
+  void freeze (int lit);
+  void melt (int lit);          // Also needs 'require (frozen (lit))'.
+
+  //------------------------------------------------------------------------
+
+  // Root level assigned variables can be queried with this function.
+  // It returns '1' if the literal is implied by the formula, '-1' if its
+  // negation is implied, or '0' if this is unclear at this point.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  int fixed (int lit) const;
+
+  //------------------------------------------------------------------------
+  // Force the default decision phase of a variable to a certain value.
+  //
+  void phase (int lit);
+  void unphase (int lit);
+
+  //------------------------------------------------------------------------
+
+  // Enables clausal proof tracing in DRAT format and returns 'true' if
+  // successfully opened for writing.  Writing proofs has to be enabled
+  // before calling 'solve', 'add' and 'dimacs', that is in state
+  // 'CONFIGURING'.  Otherwise only partial proofs would be written.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  bool trace_proof (FILE * file, const char * name); // Write DRAT proof.
+  bool trace_proof (const char * path);              // Open & write proof.
+
+  // Flush proof trace file.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void flush_proof_trace ();
+
+  // Close proof trace early.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void close_proof_trace ();
+
+  //------------------------------------------------------------------------
+
+  static void usage (); // print usage information for long options
+
+  static void configurations (); // print configuration usage options
+
+  //   require (!DELETING)
+  //   ensure (!DELETING)
+  //
+  void statistics ();   // print statistics
+  void resources ();    // print resource usage (time and memory)
+
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void options ();      // print current option and value list
+
+  //------------------------------------------------------------------------
+  // Traverse irredundant clauses or the extension stack in reverse order.
+  //
+  // The return value is false if traversal is aborted early due to one of
+  // the visitor functions returning false.  See description of the
+  // iterators below for more details on how to use these functions.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  bool traverse_clauses (ClauseIterator &) const;
+  bool traverse_witnesses_backward (WitnessIterator &) const;
+  bool traverse_witnesses_forward (WitnessIterator &) const;
+
+  //------------------------------------------------------------------------
+  // Files with explicit path argument support compressed input and output
+  // if appropriate helper functions 'gzip' etc. are available.  They are
+  // called through opening a pipe to an external command.
+  //
+  // If the 'strict' argument is zero then the number of variables and
+  // clauses specified in the DIMACS headers are ignored, i.e., the header
+  // 'p cnf 0 0' is always legal.  If the 'strict' argument is larger '1'
+  // strict formatting of the header is required, i.e., single spaces
+  // everywhere and no trailing white space.
+  //
+  // Returns zero if successful and otherwise an error message.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char * read_dimacs (FILE * file,
+                            const char * name, int & vars, int strict = 1);
+
+  const char * read_dimacs (const char * path, int & vars, int strict = 1);
+
+  // The following routines work the same way but parse both DIMACS and
+  // INCCNF files (with 'p inccnf' header and 'a <cube>' lines).  If the
+  // parser finds and 'p inccnf' header or cubes then '*incremental' is set
+  // to true and the cubes are stored in the given vector (each cube
+  // terminated by a zero).
+
+  const char * read_dimacs (FILE * file,
+                            const char * name, int & vars, int strict,
+                            bool & incremental, std::vector<int> & cubes);
+
+  const char * read_dimacs (const char * path, int & vars, int strict,
+                            bool & incremental, std::vector<int> & cubes);
+
+  //------------------------------------------------------------------------
+  // Write current irredundant clauses and all derived unit clauses
+  // to a file in DIMACS format.  Clauses on the extension stack are
+  // not included, nor any redundant clauses.
+  //
+  // The 'min_max_var' parameter gives a lower bound on the number '<vars>'
+  // of variables used in the DIMACS 'p cnf <vars> ...' header.
+  //
+  // Returns zero if successful and otherwise an error message.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char * write_dimacs (const char * path, int min_max_var = 0);
+
+  // The extension stack for reconstruction a solution can be written too.
+  //
+  const char * write_extension (const char * path);
+
+  // Print build configuration to a file with prefix 'c '.  If the file
+  // is '<stdout>' or '<stderr>' then terminal color codes might be used.
+  //
+  static void build (FILE * file, const char * prefix = "c ");
+
+private:
+
+  //==== start of state ====================================================
+
+  State _state;            // API states as discussed above.
+
+  /*----------------------------------------------------------------------*/
+
+  // The 'Solver' class is a 'facade' object for 'External'.  It exposes the
+  // public API of 'External' but hides everything else (except for the some
+  // private functions).  It is supposed to make it easier to understand the
+  // API and use the solver through the API.
+
+  // This approach has the benefit of decoupling this header file from all
+  // internal data structures, which is particularly useful if the rest of
+  // the source is not available. For instance if only a CaDiCaL library is
+  // installed in a system, then only this header file has to be installed
+  // too, and still allows to compile and link against the library.
+
+  /*----------------------------------------------------------------------*/
+
+  // More precisely the CaDiCaL code is split into three layers:
+  //
+  //   Solver:       facade object providing the actual API of the solver
+  //   External:     communication layer between 'Solver' and 'Internal'
+  //   Internal:     the actual solver code
+  //
+  // The 'External' and 'Internal' layers are declared and implemented in
+  // the corresponding '{external,internal}.{hpp,cpp}' files (as expected),
+  // while the 'Solver' facade class is defined in 'cadical.hpp' (here) but
+  // implemented in 'solver.cpp'.  The reason for this naming mismatch is,
+  // that we want to use 'cadical.hpp' for the library header (this header
+  // file) and call the binary of the stand alone SAT also 'cadical', which
+  // is more naturally implemented in 'cadical.cpp'.
+  //
+  // Separating 'External' from 'Internal' also allows us to map external
+  // literals to internal literals, which is useful with many fixed or
+  // eliminated variables (during 'compact' the internal variable range is
+  // reduced and external variables are remapped).  Such an approach is also
+  // necessary, if we want to use extended resolution in the future (such as
+  // bounded variable addition).
+  //
+  Internal * internal;     // Hidden internal solver.
+  External * external;     // Hidden API to internal solver mapping.
+
+#ifndef NTRACING
+  // The API calls to the solver can be traced by setting the environment
+  // variable 'CADICAL_API_TRACE' to point to the path of a file to which
+  // API calls are written. The same format is used which 'mobical' can
+  // read, execute and also shrink through delta debugging.
+  //
+  // The environment variable is read in the constructor and the trace is
+  // opened for writing and then closed again in the destructor.
+  //
+  // Alternatively one case use 'trace_api_calls'.  Both
+  //
+  bool close_trace_api_file; // Close file if owned by solver it.
+  FILE * trace_api_file;     // Also acts as flag that we are tracing.
+
+  static bool tracing_api_through_environment;
+
+  //===== end of state ====================================================
+
+  void trace_api_call (const char *) const;
+  void trace_api_call (const char *, int) const;
+  void trace_api_call (const char *, const char *, int) const;
+#endif
+
+  void transition_to_unknown_state ();
+
+  //------------------------------------------------------------------------
+  // Used in the stand alone solver application 'App' and the model based
+  // tester 'Mobical'.  So only these two classes need direct access to the
+  // otherwise more application specific functions listed here together with
+  // the internal DIMACS parser.
+
+  friend class App;
+  friend class Mobical;
+  friend class Parser;
+
+  // Read solution in competition format for debugging and testing.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char * read_solution (const char * path);
+
+  // This gives warning messages for wrong 'printf' style format string usage.
+  // Apparently (on 'gcc 9' at least) the first argument is 'this' here.
+  // TODO: support for other compilers (beside 'gcc' and 'clang').
+  //
+# define CADICAL_ATTRIBUTE_FORMAT(FORMAT_POSITION,VARIADIC_ARGUMENT_POSITION) \
+    __attribute__ ((format (printf, FORMAT_POSITION, VARIADIC_ARGUMENT_POSITION)))
+
+  // Messages in a common style.
+  //
+  //   require (VALID | DELETING)
+  //   ensure (VALID | DELETING)
+  //
+  void section (const char *);          // print section header
+  void message (const char *, ...)      // ordinary message
+                CADICAL_ATTRIBUTE_FORMAT (2, 3);
+
+  void message ();                      // empty line - only prefix
+  void error (const char *, ...)        // produce error message
+              CADICAL_ATTRIBUTE_FORMAT (2, 3);
+
+  // Explicit verbose level ('section' and 'message' use '0').
+  //
+  //   require (VALID | DELETING)
+  //   ensure (VALID | DELETING)
+  //
+  void verbose (int level, const char *, ...)
+                           CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  // Factoring out common code to both 'read_dimacs' functions above.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char * read_dimacs (File *, int &, int strict,
+                            bool * incremental = 0,
+                            std::vector<int> * = 0);
+
+  // Factored out common code for 'solve', 'simplify' and 'lookahead'.
+  //
+  int call_external_solve_and_check_results (bool preprocess_only);
+
+  //------------------------------------------------------------------------
+  // Print DIMACS file to '<stdout>' for debugging and testing purposes,
+  // including derived units and assumptions.  Since it will print in terms
+  // of internal literals it is otherwise not really useful.  To write a
+  // DIMACS formula in terms of external variables use 'write_dimacs'.
+  //
+  //   require (!INITIALIZING)
+  //   ensure (!INITIALIZING)
+  //
+  void dump_cnf ();
+  friend struct DumpCall; // Mobical calls 'dump_cnf' in 'DumpCall::execute'
+};
+
+/*========================================================================*/
+
+// Connected terminators are checked for termination regularly.  If the
+// 'terminate' function of the terminator returns true the solver is
+// terminated synchronously as soon it calls this function.
+
+class Terminator {
+public:
+  virtual ~Terminator () { }
+  virtual bool terminate () = 0;
+};
+
+// Connected learners which can be used to export learned clauses.
+// The 'learning' can check the size of the learn clause and only if it
+// returns true then the individual literals of the learned clause are given
+// to the learn through 'learn' one by one terminated by a zero literal.
+
+class Learner {
+public:
+  virtual ~Learner () { }
+  virtual bool learning (int size) = 0;
+  virtual void learn (int lit) = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+// Allows to traverse all remaining irredundant clauses.  Satisfied and
+// eliminated clauses are not included, nor any derived units unless such
+// a unit literal is frozen. Falsified literals are skipped.  If the solver
+// is inconsistent only the empty clause is traversed.
+//
+// If 'clause' returns false traversal aborts early.
+
+class ClauseIterator {
+public:
+  virtual ~ClauseIterator () { }
+  virtual bool clause (const std::vector<int> &) = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+// Allows to traverse all clauses on the extension stack together with their
+// witness cubes.  If the solver is inconsistent, i.e., an empty clause is
+// found and the formula is unsatisfiable, then nothing is traversed.
+//
+// The clauses traversed in 'traverse_clauses' together with the clauses on
+// the extension stack are logically equivalent to the original clauses.
+// See our SAT'19 paper for more details.
+//
+// The witness literals can be used to extend and fix an assignment on the
+// remaining clauses to satisfy the clauses on the extension stack too.
+//
+// All derived units of non-frozen variables are included too.
+//
+// If 'witness' returns false traversal aborts early.
+
+class WitnessIterator {
+public:
+  virtual ~WitnessIterator () { }
+  virtual bool witness (const std::vector<int> & clause,
+                        const std::vector<int> & witness) = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+}
+
+#endif
diff --git a/hCaD_V2/src/ccadical.cpp b/hCaD_V2/src/ccadical.cpp
new file mode 100644
index 0000000..2141c56
--- /dev/null
+++ b/hCaD_V2/src/ccadical.cpp
@@ -0,0 +1,172 @@
+#include "cadical.hpp"
+
+#include <cstdlib>
+#include <cstring>
+
+namespace CaDiCaL {
+
+struct Wrapper : Learner, Terminator {
+
+  Solver * solver;
+  struct {
+    void * state;
+    int (*function) (void *);
+  } terminator;
+
+  struct {
+    void * state;
+    int max_length;
+    int * begin_clause, * end_clause, * capacity_clause;
+    void (*function) (void *, int *);
+  } learner;
+
+  bool terminate () {
+    if (!terminator.function)
+      return false;
+    return terminator.function (terminator.state);
+  }
+
+  bool learning (int size) {
+    if (!learner.function)
+      return false;
+    return size <= learner.max_length;
+  }
+
+  void learn (int lit) {
+    if (learner.end_clause == learner.capacity_clause) {
+      size_t count = learner.end_clause - learner.begin_clause;
+      size_t size = count ? 2*count : 1;
+      learner.begin_clause = (int*)
+        realloc (learner.begin_clause, size * sizeof (int));
+      learner.end_clause = learner.begin_clause + count;
+      learner.capacity_clause = learner.begin_clause + size;
+    }
+    *learner.end_clause++ = lit;
+    if (lit)
+      return;
+    learner.function (learner.state, learner.begin_clause);
+    learner.end_clause = learner.begin_clause;
+  }
+
+  Wrapper () : solver (new Solver ()) {
+    memset (&terminator, 0, sizeof terminator);
+    memset (&learner, 0, sizeof learner);
+  }
+
+  ~Wrapper () {
+    terminator.function = 0;
+    if (learner.begin_clause) free (learner.begin_clause);
+    delete solver; }
+};
+
+}
+
+using namespace CaDiCaL;
+
+extern "C" {
+
+#include "ccadical.h"
+
+const char * ccadical_signature (void) {
+  return Solver::signature ();
+}
+
+CCaDiCaL * ccadical_init (void) {
+  return (CCaDiCaL*) new Wrapper ();
+}
+
+void ccadical_release (CCaDiCaL * wrapper) {
+  delete (Wrapper*) wrapper;
+}
+
+void ccadical_set_option (CCaDiCaL * wrapper,
+                          const char * name, int val) {
+  ((Wrapper*) wrapper)->solver->set (name, val);
+}
+
+void ccadical_limit (CCaDiCaL * wrapper,
+                     const char * name, int val) {
+  ((Wrapper*) wrapper)->solver->limit (name, val);
+}
+
+int ccadical_get_option (CCaDiCaL * wrapper, const char * name) {
+  return ((Wrapper*) wrapper)->solver->get (name);
+}
+
+void ccadical_add (CCaDiCaL * wrapper, int lit) {
+  ((Wrapper*) wrapper)->solver->add (lit);
+}
+
+void ccadical_assume (CCaDiCaL * wrapper, int lit) {
+  ((Wrapper*) wrapper)->solver->assume (lit);
+}
+
+int ccadical_solve (CCaDiCaL * wrapper) {
+  return ((Wrapper*) wrapper)->solver->solve ();
+}
+
+int ccadical_simplify (CCaDiCaL * wrapper) {
+  return ((Wrapper*) wrapper)->solver->simplify ();
+}
+
+int ccadical_val (CCaDiCaL * wrapper, int lit) {
+  return ((Wrapper*) wrapper)->solver->val (lit);
+}
+
+int ccadical_failed (CCaDiCaL * wrapper, int lit) {
+  return ((Wrapper*) wrapper)->solver->failed (lit);
+}
+
+void ccadical_print_statistics (CCaDiCaL * wrapper) {
+  ((Wrapper*) wrapper)->solver->statistics ();
+}
+
+void ccadical_terminate (CCaDiCaL * wrapper) {
+  ((Wrapper*) wrapper)->solver->terminate ();
+}
+
+int64_t ccadical_active (CCaDiCaL * wrapper) {
+  return ((Wrapper*) wrapper)->solver->active ();
+}
+
+int64_t ccadical_irredundant (CCaDiCaL * wrapper) {
+  return ((Wrapper*) wrapper)->solver->irredundant ();
+}
+
+int ccadical_fixed (CCaDiCaL * wrapper, int lit) {
+  return ((Wrapper*) wrapper)->solver->fixed (lit);
+}
+
+void ccadical_set_terminate (CCaDiCaL * ptr,
+                             void * state, int (*terminate)(void *)) {
+  Wrapper * wrapper = (Wrapper *) ptr;
+  wrapper->terminator.state = state;
+  wrapper->terminator.function = terminate;
+  if (terminate) wrapper->solver->connect_terminator (wrapper);
+  else wrapper->solver->disconnect_terminator ();
+}
+
+void ccadical_set_learn (CCaDiCaL * ptr,
+                         void * state, int max_length,
+                         void (*learn)(void * state, int * clause)) {
+  Wrapper * wrapper = (Wrapper *) ptr;
+  wrapper->learner.state = state;
+  wrapper->learner.max_length = max_length;
+  wrapper->learner.function = learn;
+  if (learn) wrapper->solver->connect_learner (wrapper);
+  else wrapper->solver->disconnect_learner ();
+}
+
+void ccadical_freeze (CCaDiCaL * ptr, int lit) {
+  ((Wrapper*) ptr)->solver->freeze (lit);
+}
+
+void ccadical_melt (CCaDiCaL * ptr, int lit) {
+  ((Wrapper*) ptr)->solver->melt (lit);
+}
+
+int ccadical_frozen (CCaDiCaL * ptr, int lit) {
+  return ((Wrapper*) ptr)->solver->frozen (lit);
+}
+
+}
diff --git a/hCaD_V2/src/ccadical.h b/hCaD_V2/src/ccadical.h
new file mode 100644
index 0000000..4173aed
--- /dev/null
+++ b/hCaD_V2/src/ccadical.h
@@ -0,0 +1,63 @@
+#ifndef _ccadical_h_INCLUDED
+#define _ccadical_h_INCLUDED
+
+/*------------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*------------------------------------------------------------------------*/
+
+#include <stdint.h>
+
+// C wrapper for CaDiCaL's C++ API following IPASIR.
+
+typedef struct CCaDiCaL CCaDiCaL;
+
+const char * ccadical_signature (void);
+CCaDiCaL * ccadical_init (void);
+void ccadical_release (CCaDiCaL *);
+
+void ccadical_add (CCaDiCaL *, int lit);
+void ccadical_assume (CCaDiCaL *, int lit);
+int ccadical_solve (CCaDiCaL *);
+int ccadical_val (CCaDiCaL *, int lit);
+int ccadical_failed (CCaDiCaL *, int lit);
+
+void ccadical_set_terminate (CCaDiCaL *,
+  void * state, int (*terminate)(void * state));
+
+void ccadical_set_learn (CCaDiCaL *,
+  void * state, int max_length, void (*learn)(void * state, int * clause));
+
+/*------------------------------------------------------------------------*/
+
+// Non-IPASIR conformant 'C' functions.
+
+void ccadical_set_option (CCaDiCaL *, const char * name, int val);
+void ccadical_limit (CCaDiCaL *, const char * name, int limit);
+int ccadical_get_option (CCaDiCaL *, const char * name);
+void ccadical_print_statistics (CCaDiCaL *);
+int64_t ccadical_active (CCaDiCaL *);
+int64_t ccadical_irredundant (CCaDiCaL *);
+int ccadical_fixed (CCaDiCaL *, int lit);
+void ccadical_terminate (CCaDiCaL *);
+void ccadical_freeze (CCaDiCaL *, int lit);
+int ccadical_frozen (CCaDiCaL *, int lit);
+void ccadical_melt (CCaDiCaL *, int lit);
+int ccadical_simplify (CCaDiCaL *);
+
+/*------------------------------------------------------------------------*/
+
+// Support legacy names used before moving to more IPASIR conforming names.
+
+#define ccadical_reset ccadical_release
+#define ccadical_sat ccadical_solve
+#define ccadical_deref ccadical_val
+
+/*------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/hCaD_V2/src/checker.cpp b/hCaD_V2/src/checker.cpp
new file mode 100644
index 0000000..1257f47
--- /dev/null
+++ b/hCaD_V2/src/checker.cpp
@@ -0,0 +1,555 @@
+#include "internal.hpp"
+
+extern "C" {
+#include <inttypes.h>
+}
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+inline unsigned Checker::l2u (int lit) {
+   assert (lit);
+   assert (lit != INT_MIN);
+   unsigned res = 2*(abs (lit) - 1);
+   if (lit < 0) res++;
+   return res;
+}
+
+inline signed char Checker::val (int lit) {
+  assert (lit);
+  assert (lit != INT_MIN);
+  assert (abs (lit) < size_vars);
+  assert (vals[lit] == -vals[-lit]);
+  return vals[lit];
+}
+
+signed char & Checker::mark (int lit) {
+  const unsigned u = l2u (lit);
+  assert (u < marks.size ());
+  return marks[u];
+}
+
+inline CheckerWatcher & Checker::watcher (int lit) {
+  const unsigned u = l2u (lit);
+  assert (u < watchers.size ());
+  return watchers[u];
+}
+
+/*------------------------------------------------------------------------*/
+
+CheckerClause * Checker::new_clause () {
+  const size_t size = simplified.size ();
+  assert (size > 1), assert (size <= UINT_MAX);
+  const size_t bytes = sizeof (CheckerClause) + (size - 2) * sizeof (int);
+  CheckerClause * res = (CheckerClause *) new char [bytes];
+  res->next = 0;
+  res->hash = last_hash;
+  res->size = size;
+  int * literals = res->literals, * p = literals;
+  for (const auto & lit : simplified)
+    *p++ = lit;
+  num_clauses++;
+
+  // First two literals are used as watches and should not be false.
+  //
+  for (unsigned i = 0; i < 2; i++) {
+    int lit = literals[i];
+    if (!val (lit)) continue;
+    for (unsigned j = i + 1; j < size; j++) {
+      int other = literals[j];
+      if (val (other)) continue;
+      swap (literals[i], literals[j]);
+      break;
+    }
+  }
+  assert (!val (literals [0]));
+  assert (!val (literals [1]));
+  watcher (literals[0]).push_back (CheckerWatch (literals[1], res));
+  watcher (literals[1]).push_back (CheckerWatch (literals[0], res));
+
+  return res;
+}
+
+void Checker::delete_clause (CheckerClause * c) {
+  if (c->size) {
+    assert (c->size > 1);
+    assert (num_clauses);
+    num_clauses--;
+  } else {
+    assert (num_garbage);
+    num_garbage--;
+  }
+  delete [] (char*) c;
+}
+
+void Checker::enlarge_clauses () {
+  assert (num_clauses == size_clauses);
+  const uint64_t new_size_clauses = size_clauses ? 2*size_clauses : 1;
+  LOG ("CHECKER enlarging clauses of checker from %" PRIu64 " to %" PRIu64,
+    (uint64_t) size_clauses, (uint64_t) new_size_clauses);
+  CheckerClause ** new_clauses;
+  new_clauses = new CheckerClause * [ new_size_clauses ];
+  clear_n (new_clauses, new_size_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++) {
+    for (CheckerClause * c = clauses[i], * next; c; c = next) {
+      next = c->next;
+      const uint64_t h = reduce_hash (c->hash, new_size_clauses);
+      c->next = new_clauses[h];
+      new_clauses[h] = c;
+    }
+  }
+  delete [] clauses;
+  clauses = new_clauses;
+  size_clauses = new_size_clauses;
+}
+
+bool Checker::clause_satisfied (CheckerClause * c) {
+  for (unsigned i = 0; i < c->size; i++)
+    if (val (c->literals[i]) > 0)
+      return true;
+  return false;
+}
+
+// The main reason why we have an explicit garbage collection phase is that
+// removing clauses from watcher lists eagerly might lead to an accumulated
+// quadratic algorithm.  Thus we delay removing garbage clauses from watcher
+// lists until garbage collection (even though we remove garbage clauses on
+// the fly during propagation too).  We also remove satisfied clauses.
+//
+void Checker::collect_garbage_clauses () {
+
+  stats.collections++;
+
+  for (size_t i = 0; i < size_clauses; i++) {
+    CheckerClause ** p = clauses + i, * c;
+    while ((c = *p)) {
+      if (clause_satisfied (c)) {
+        c->size = 0;                    // mark as garbage
+        *p = c->next;
+        c->next = garbage;
+        garbage = c;
+        num_garbage++;
+        assert (num_clauses);
+        num_clauses--;
+      } else p = &c->next;
+    }
+  }
+
+  LOG ("CHECKER collecting %" PRIu64 " garbage clauses %.0f%%",
+    num_garbage, percent (num_garbage, num_clauses));
+
+  for (int lit = -size_vars + 1; lit < size_vars; lit++) {
+    if (!lit) continue;
+    CheckerWatcher & ws = watcher (lit);
+    const auto end = ws.end ();
+    auto j = ws.begin (), i = j;
+    for (;i != end; i++) {
+      CheckerWatch & w = *i;
+      if (w.clause->size) *j++ = w;
+    }
+    if (j == ws.end ()) continue;
+    if (j == ws.begin ()) erase_vector (ws);
+    else ws.resize (j - ws.begin ());
+  }
+
+  for (CheckerClause * c = garbage, * next; c; c = next)
+    next = c->next, delete_clause (c);
+
+  assert (!num_garbage);
+  garbage = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+Checker::Checker (Internal * i)
+:
+  internal (i),
+  size_vars (0), vals (0),
+  inconsistent (false), num_clauses (0), num_garbage (0),
+  size_clauses (0), clauses (0), garbage (0),
+  next_to_propagate (0), last_hash (0)
+{
+  LOG ("CHECKER new");
+
+  // Initialize random number table for hash function.
+  //
+  Random random (42);
+  for (unsigned n = 0; n < num_nonces; n++) {
+    uint64_t nonce = random.next ();
+    if (!(nonce & 1)) nonce++;
+    assert (nonce), assert (nonce & 1);
+    nonces[n] = nonce;
+  }
+
+  memset (&stats, 0, sizeof (stats));           // Initialize statistics.
+}
+
+Checker::~Checker () {
+  LOG ("CHECKER delete");
+  vals -= size_vars;
+  delete [] vals;
+  for (size_t i = 0; i < size_clauses; i++)
+    for (CheckerClause * c = clauses[i], * next; c; c = next)
+      next = c->next, delete_clause (c);
+  for (CheckerClause * c = garbage, * next; c; c = next)
+    next = c->next, delete_clause (c);
+  delete [] clauses;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The simplicity for accessing 'vals' and 'watchers' directly through a
+// signed integer literal, comes with the price of slightly more complex
+// code in deleting and enlarging the checker data structures.
+
+void Checker::enlarge_vars (int64_t idx) {
+
+  assert (0 < idx), assert (idx <= INT_MAX);
+
+  int64_t new_size_vars = size_vars ? 2*size_vars : 2;
+  while (idx >= new_size_vars) new_size_vars *= 2;
+  LOG ("CHECKER enlarging variables of checker from %" PRId64 " to %" PRId64 "",
+    size_vars, new_size_vars);
+
+  signed char * new_vals;
+  new_vals = new signed char [ 2*new_size_vars ];
+  clear_n (new_vals, 2*new_size_vars);
+  new_vals += new_size_vars;
+  if (size_vars) // To make sanitizer happy (without '-O').
+    memcpy ((void*) (new_vals - size_vars),
+            (void*) (vals - size_vars), 2*size_vars);
+  vals -= size_vars;
+  delete [] vals;
+  vals = new_vals;
+
+  watchers.resize (2*new_size_vars);
+  marks.resize (2*new_size_vars);
+
+  assert (idx < new_size_vars);
+  size_vars = new_size_vars;
+}
+
+inline void Checker::import_literal (int lit) {
+  assert (lit);
+  assert (lit != INT_MIN);
+  int idx = abs (lit);
+  if (idx >= size_vars) enlarge_vars (idx);
+  simplified.push_back (lit);
+  unsimplified.push_back (lit);
+}
+
+void Checker::import_clause (const vector<int> & c) {
+  for (const auto & lit : c)
+    import_literal (lit);
+}
+
+struct lit_smaller {
+  bool operator () (int a, int b) const {
+    int c = abs (a), d = abs (b);
+    if (c < d) return true;
+    if (c > d) return false;
+    return a < b;
+  }
+};
+
+bool Checker::tautological () {
+  sort (simplified.begin (), simplified.end (), lit_smaller ());
+  const auto end = simplified.end ();
+  auto j = simplified.begin ();
+  int prev = 0;
+  for (auto i = j; i != end; i++) {
+    int lit = *i;
+    if (lit == prev) continue;          // duplicated literal
+    if (lit == -prev) return true;      // tautological clause
+    const signed char tmp = val (lit);
+    if (tmp > 0) return true;           // satisfied literal and clause
+    *j++ = prev = lit;
+  }
+  simplified.resize (j - simplified.begin ());
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+uint64_t Checker::reduce_hash (uint64_t hash, uint64_t size) {
+  assert (size > 0);
+  unsigned shift = 32;
+  uint64_t res = hash;
+  while ((((uint64_t)1) << shift) > size) {
+    res ^= res >> shift;
+    shift >>= 1;
+  }
+  res &= size - 1;
+  assert (res < size);
+  return res;
+}
+
+uint64_t Checker::compute_hash () {
+  unsigned i = 0, j = 0;
+  uint64_t tmp = 0;
+  for (i = 0; i < simplified.size (); i++) {
+    int lit = simplified[i];
+    tmp += nonces[j++] * (uint64_t) lit;
+    if (j == num_nonces) j = 0;
+  }
+  return last_hash = tmp;
+}
+
+CheckerClause ** Checker::find () {
+  stats.searches++;
+  CheckerClause ** res, * c;
+  const uint64_t hash = compute_hash ();
+  const unsigned size = simplified.size ();
+  const uint64_t h = reduce_hash (hash, size_clauses);
+  for (const auto & lit : simplified) mark (lit) = true;
+  for (res = clauses + h; (c = *res); res = &c->next) {
+    if (c->hash == hash && c->size == size) {
+      bool found = true;
+      const int * literals = c->literals;
+      for (unsigned i = 0; found && i != size; i++)
+        found = mark (literals[i]);
+      if (found) break;
+    }
+    stats.collisions++;
+  }
+  for (const auto & lit : simplified) mark (lit) = false;
+  return res;
+}
+
+void Checker::insert () {
+  stats.insertions++;
+  if (num_clauses == size_clauses) enlarge_clauses ();
+  const uint64_t h = reduce_hash (compute_hash (), size_clauses);
+  CheckerClause * c = new_clause ();
+  c->next = clauses[h];
+  clauses[h] = c;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void Checker::assign (int lit) {
+  assert (!val (lit));
+  vals[lit] = 1;
+  vals[-lit] = -1;
+  trail.push_back (lit);
+}
+
+inline void Checker::assume (int lit) {
+  signed char tmp = val (lit);
+  if (tmp > 0) return;
+  assert (!tmp);
+  stats.assumptions++;
+  assign (lit);
+}
+
+void Checker::backtrack (unsigned previously_propagated) {
+
+  assert (previously_propagated <= trail.size ());
+
+  while (trail.size () > previously_propagated) {
+    int lit = trail.back ();
+    assert (val (lit) > 0);
+    assert (val (-lit) < 0);
+    vals[lit] = vals[-lit] = 0;
+    trail.pop_back ();
+  }
+
+  trail.resize (previously_propagated);
+  next_to_propagate = previously_propagated;
+  assert (trail.size () == next_to_propagate);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is a standard propagation routine without using blocking literals
+// nor without saving the last replacement position.
+
+bool Checker::propagate () {
+  bool res = true;
+  while (res && next_to_propagate < trail.size ()) {
+    int lit = trail[next_to_propagate++];
+    stats.propagations++;
+    assert (val (lit) > 0);
+    assert (abs (lit) < size_vars);
+    CheckerWatcher & ws = watcher (-lit);
+    const auto end = ws.end ();
+    auto j = ws.begin (), i = j;
+    for (; res && i != end; i++) {
+      CheckerWatch & w = *j++ = *i;
+      const int blit = w.blit;
+      assert (blit != -lit);
+      const signed char blit_val = val (blit);
+      if (blit_val > 0) continue;
+      const unsigned size = w.size;
+      if (size == 2) {                          // not precise since
+        if (blit_val < 0) res = false;          // clause might be garbage
+        else assign (w.blit);                   // but still sound
+      } else {
+        assert (size > 2);
+        CheckerClause * c = w.clause;
+        if (!c->size) { j--; continue; }        // skip garbage clauses
+        assert (size == c->size);
+        int * lits = c->literals;
+        int other = lits[0]^lits[1]^(-lit);
+        assert (other != -lit);
+        signed char other_val = val (other);
+        if (other_val > 0) { j[-1].blit = other; continue; }
+        lits[0] = other, lits[1] = -lit;
+        unsigned k;
+        int replacement = 0;
+        signed char replacement_val = -1;
+        for (k = 2; k < size; k++)
+          if ((replacement_val = val (replacement = lits[k])) >= 0)
+            break;
+        if (replacement_val >= 0) {
+          watcher (replacement).push_back (CheckerWatch (-lit, c));
+          swap (lits[1], lits[k]);
+          j--;
+        } else if (!other_val) assign (other);
+        else res = false;
+      }
+    }
+    while (i != end) *j++ = *i++;
+    ws.resize (j - ws.begin ());
+  }
+  return res;
+}
+
+bool Checker::check () {
+  stats.checks++;
+  if (inconsistent) return true;
+  unsigned previously_propagated = next_to_propagate;
+  for (const auto & lit : simplified)
+    assume (-lit);
+  bool res = !propagate ();
+  backtrack (previously_propagated);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Checker::add_clause (const char * type) {
+#ifndef LOGGING
+  (void) type;
+#endif
+
+  int unit = 0;
+  for (const auto & lit : simplified) {
+    const signed char tmp = val (lit);
+    if (tmp < 0) continue;
+    assert (!tmp);
+    if (unit) { unit = INT_MIN; break; }
+    unit = lit;
+  }
+
+  if (simplified.empty ()) {
+    LOG ("CHECKER added empty %s clause", type);
+    inconsistent = true;
+  } if (!unit) {
+    LOG ("CHECKER added and checked falsified %s clause", type);
+    inconsistent = true;
+  } else if (unit != INT_MIN) {
+    LOG ("CHECKER added and checked %s unit clause %d", type, unit);
+    assign (unit);
+    stats.units++;
+    if (!propagate ()) {
+      LOG ("CHECKER inconsistent after propagating %s unit", type);
+      inconsistent = true;
+    }
+  } else insert ();
+}
+
+void Checker::add_original_clause (const vector<int> & c) {
+  if (inconsistent) return;
+  START (checking);
+  LOG (c, "CHECKER addition of original clause");
+  stats.added++;
+  stats.original++;
+  import_clause (c);
+  if (tautological ())
+    LOG ("CHECKER ignoring satisfied original clause");
+  else add_clause ("original");
+  simplified.clear ();
+  unsimplified.clear ();
+  STOP (checking);
+}
+
+void Checker::add_derived_clause (const vector<int> & c) {
+  if (inconsistent) return;
+  START (checking);
+  LOG (c, "CHECKER addition of derived clause");
+  stats.added++;
+  stats.derived++;
+  import_clause (c);
+  if (tautological ())
+    LOG ("CHECKER ignoring satisfied derived clause");
+  else if (!check ()) {
+    fatal_message_start ();
+    fputs ("failed to check derived clause:\n", stderr);
+    for (const auto & lit : unsimplified)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  } else add_clause ("derived");
+  simplified.clear ();
+  unsimplified.clear ();
+  STOP (checking);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Checker::delete_clause (const vector<int> & c) {
+  if (inconsistent) return;
+  START (checking);
+  LOG (c, "CHECKER checking deletion of clause");
+  stats.deleted++;
+  import_clause (c);
+  if (!tautological ()) {
+    CheckerClause ** p = find (), * d = *p;
+    if (d) {
+      assert (d->size > 1);
+      // Remove from hash table, mark as garbage, connect to garbage list.
+      num_garbage++;
+      assert (num_clauses);
+      num_clauses--;
+      *p = d->next;
+      d->next = garbage;
+      garbage = d;
+      d->size = 0;
+      // If there are enough garbage clauses collect them.
+      if (num_garbage > 0.5 * max ((size_t) size_clauses, (size_t) size_vars))
+        collect_garbage_clauses ();
+    } else {
+      fatal_message_start ();
+      fputs ("deleted clause not in proof:\n", stderr);
+      for (const auto & lit : unsimplified)
+        fprintf (stderr, "%d ", lit);
+      fputc ('0', stderr);
+      fatal_message_end ();
+    }
+  }
+  simplified.clear ();
+  unsimplified.clear ();
+  STOP (checking);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Checker::dump () {
+  int max_var = 0;
+  for (uint64_t i = 0; i < size_clauses; i++)
+    for (CheckerClause * c = clauses[i]; c; c = c->next)
+      for (unsigned i = 0; i < c->size; i++)
+        if (abs (c->literals[i]) > max_var)
+          max_var = abs (c->literals[i]);
+  printf ("p cnf %d %" PRIu64 "\n", max_var, num_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++)
+    for (CheckerClause * c = clauses[i]; c; c = c->next) {
+      for (unsigned i = 0; i < c->size; i++)
+        printf ("%d ", c->literals[i]);
+      printf ("0\n");
+    }
+}
+
+}
diff --git a/hCaD_V2/src/checker.hpp b/hCaD_V2/src/checker.hpp
new file mode 100644
index 0000000..90bfa7e
--- /dev/null
+++ b/hCaD_V2/src/checker.hpp
@@ -0,0 +1,165 @@
+#ifndef _checker_hpp_INCLUDED
+#define _checker_hpp_INCLUDED
+
+#include "observer.hpp"         // Alphabetically after 'checker'.
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This checker implements an online forward DRUP proof checker enabled by
+// 'opts.checkproof' (requires 'opts.check' also to be enabled).  This is
+// useful for model basted testing (and delta-debugging), where we can not
+// rely on an external proof checker such as 'drat-trim'.  We also do not
+// have yet  a flow for offline incremental proof checking, while this
+// checker here can also be used in an incremental setting.
+//
+// In essence the checker implements is a simple propagation online SAT
+// solver with an additional hash table to find clauses fast for
+// 'delete_clause'.  It requires its own data structure for clauses
+// ('CheckerClause') and watches ('CheckerWatch').
+//
+// In our experiments the checker slows down overall SAT solving time by a
+// factor of 3, which we contribute to its slightly less efficient
+// implementation.
+
+/*------------------------------------------------------------------------*/
+
+struct CheckerClause {
+  CheckerClause * next;         // collision chain link for hash table
+  uint64_t hash;                // previously computed full 64-bit hash
+  unsigned size;                // zero if this is a garbage clause
+  int literals[2];              // otherwise 'literals' of length 'size'
+};
+
+struct CheckerWatch {
+  int blit;
+  unsigned size;
+  CheckerClause * clause;
+  CheckerWatch () { }
+  CheckerWatch (int b, CheckerClause * c) :
+    blit (b), size (c->size), clause (c)
+  { }
+};
+
+typedef vector<CheckerWatch> CheckerWatcher;
+
+/*------------------------------------------------------------------------*/
+
+class Checker : public Observer {
+
+  Internal * internal;
+
+  // Capacity of variable values.
+  //
+  int64_t size_vars;
+
+  // For the assignment we want to have an as fast access as possible and
+  // thus we use an array which can also be indexed by negative literals and
+  // is actually valid in the range [-size_vars+1, ..., size_vars-1].
+  //
+  signed char * vals;
+
+  // The 'watchers' and 'marks' data structures are not that time critical
+  // and thus we access them by first mapping a literal to 'unsigned'.
+  //
+  static unsigned l2u (int lit);
+  vector<CheckerWatcher> watchers;      // watchers of literals
+  vector<signed char> marks;            // mark bits of literals
+
+  signed char & mark (int lit);
+  CheckerWatcher & watcher (int lit);
+
+  bool inconsistent;            // found or added empty clause
+
+  uint64_t num_clauses;         // number of clauses in hash table
+  uint64_t num_garbage;         // number of garbage clauses
+  uint64_t size_clauses;        // size of clause hash table
+  CheckerClause ** clauses;     // hash table of clauses
+  CheckerClause * garbage;      // linked list of garbage clauses
+
+  vector<int> unsimplified;     // original clause for reporting
+  vector<int> simplified;       // clause for sorting
+
+  vector<int> trail;            // for propagation
+
+  unsigned next_to_propagate;   // next to propagate on trail
+
+  void enlarge_vars (int64_t idx);
+  void import_literal (int lit);
+  void import_clause (const vector<int> &);
+  bool tautological ();
+
+  static const unsigned num_nonces = 4;
+
+  uint64_t nonces[num_nonces];  // random numbers for hashing
+  uint64_t last_hash;           // last computed hash value of clause
+  uint64_t compute_hash ();     // compute and save hash value of clause
+
+  // Reduce hash value to the actual size.
+  //
+  static uint64_t reduce_hash (uint64_t hash, uint64_t size);
+
+  void enlarge_clauses ();      // enlarge hash table for clauses
+  void insert ();               // insert clause in hash table
+  CheckerClause ** find ();     // find clause position in hash table
+
+  void add_clause (const char * type);
+
+  void collect_garbage_clauses ();
+
+  CheckerClause * new_clause ();
+  void delete_clause (CheckerClause *);
+
+  signed char val (int lit);            // returns '-1', '0' or '1'
+
+  bool clause_satisfied (CheckerClause*);
+
+  void assign (int lit);        // assign a literal to true
+  void assume (int lit);        // assume a literal
+  bool propagate ();            // propagate and check for conflicts
+  void backtrack (unsigned);    // prepare for next clause
+  bool check ();                // check simplified clause is implied
+
+  struct {
+
+    int64_t added;              // number of added clauses
+    int64_t original;           // number of added original clauses
+    int64_t derived;            // number of added derived clauses
+
+    int64_t deleted;            // number of deleted clauses
+
+    int64_t assumptions;        // number of assumed literals
+    int64_t propagations;       // number of propagated literals
+
+    int64_t insertions;         // number of clauses added to hash table
+    int64_t collisions;         // number of hash collisions in 'find'
+    int64_t searches;           // number of searched clauses in 'find'
+
+    int64_t checks;             // number of implication checks
+
+    int64_t collections;        // garbage collections
+    int64_t units;
+
+  } stats;
+
+public:
+
+  Checker (Internal *);
+  ~Checker ();
+
+  // The following three implement the 'Observer' interface.
+  //
+  void add_original_clause (const vector<int> &);
+  void add_derived_clause (const vector<int> &);
+  void delete_clause (const vector<int> &);
+
+  void print_stats ();
+  void dump ();                 // for debugging purposes only
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/clause.cpp b/hCaD_V2/src/clause.cpp
new file mode 100644
index 0000000..5f3b701
--- /dev/null
+++ b/hCaD_V2/src/clause.cpp
@@ -0,0 +1,442 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Signed marking or unmarking of a clause or the global 'clause'.
+
+void Internal::mark (Clause * c) {
+  for (const auto & lit : *c) mark (lit);
+}
+
+void Internal::mark2 (Clause * c) {
+  for (const auto & lit : *c) mark2 (lit);
+}
+
+void Internal::unmark (Clause * c) {
+  for (const auto & lit : *c) unmark (lit);
+}
+
+void Internal::mark_clause () {
+  for (const auto & lit : clause) mark (lit);
+}
+
+void Internal::unmark_clause () {
+  for (const auto & lit : clause) unmark (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Mark the variables of an irredundant clause to 'have been removed', which
+// will trigger these variables to be considered again in the next bounded
+// variable elimination phase.  This is called from 'mark_garbage' below.
+// Note that 'mark_removed (int lit)' will also mark the blocking flag of
+// '-lit' to trigger reconsidering blocking clauses on '-lit'.
+
+void Internal::mark_removed (Clause * c, int except) {
+  LOG (c, "marking removed");
+  assert (!c->redundant);
+  for (const auto & lit : *c)
+    if (lit != except)
+      mark_removed (lit);
+}
+
+// Mark the variables of a (redundant or irredundant) clause to 'have been
+// added', which triggers clauses with such a variables, to be considered
+// both as a subsumed or subsuming clause in the next subsumption phase.
+// This function is called from 'new_clause' below as well as in situations
+// where a clause is shrunken (and thus needs to be at least considered
+// again to subsume a larger clause).  We also use this to tell
+// 'ternary' preprocessing reconsider clauses on an added literal as well as
+// trying to block clauses on it.
+
+inline void Internal::mark_added (int lit, int size, bool redundant) {
+  mark_subsume (lit);
+  if (size == 3)
+    mark_ternary (lit);
+  if (!redundant)
+    mark_block (lit);
+}
+
+void Internal::mark_added (Clause * c) {
+  LOG (c, "marking added");
+  assert (likely_to_be_kept_clause (c));
+  for (const auto & lit : *c)
+    mark_added (lit, c->size, c->redundant);
+}
+
+/*------------------------------------------------------------------------*/
+
+Clause * Internal::new_clause (bool red, int glue) {
+
+  assert (clause.size () <= (size_t) INT_MAX);
+  const int size = (int) clause.size ();
+  assert (size >= 2);
+
+  if (glue > size) glue = size;
+
+  // Determine whether this clauses should be kept all the time.
+  //
+  bool keep;
+  if (!red) keep = true;
+  else if (glue <= opts.reducetier1glue) keep = true;
+  else keep = false;
+
+  size_t bytes = Clause::bytes (size);
+  Clause * c = (Clause *) new char[bytes];
+
+  stats.added.total++;
+#ifdef LOGGING
+  c->id = stats.added.total;
+#endif
+
+  c->conditioned = false;
+  c->covered = false;
+  c->enqueued = false;
+  c->frozen = false;
+  c->garbage = false;
+  c->gate = false;
+  c->hyper = false;
+  c->instantiated = false;
+  c->keep = keep;
+  c->moved = false;
+  c->reason = false;
+  c->redundant = red;
+  c->transred = false;
+  c->subsume = false;
+  c->vivified = false;
+  c->vivify = false;
+  c->used = 0;
+
+  c->glue = glue;
+  c->size = size;
+  c->pos = 2;
+
+  for (int i = 0; i < size; i++) c->literals[i] = clause[i];
+
+  // Just checking that we did not mess up our sophisticated memory layout.
+  // This might be compiler dependent though. Crucial for correctness.
+  //
+  assert (c->bytes () == bytes);
+
+  stats.current.total++;
+  stats.added.total++;
+
+  if (red) {
+    stats.current.redundant++;
+    stats.added.redundant++;
+  } else {
+    stats.irrbytes += bytes;
+    stats.current.irredundant++;
+    stats.added.irredundant++;
+  }
+
+  clauses.push_back (c);
+  LOG (c, "new pointer %p", (void*) c);
+
+  if (likely_to_be_kept_clause (c)) mark_added (c);
+
+  return c;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::promote_clause (Clause * c, int new_glue) {
+  assert (c->redundant);
+  if (c->keep) return;
+  if (c->hyper) return;
+  int old_glue = c->glue;
+  if (new_glue >= old_glue) return;
+  if (!c->keep && new_glue <= opts.reducetier1glue) {
+    LOG (c, "promoting with new glue %d to tier1", new_glue);
+    stats.promoted1++;
+    c->keep = true;
+  } else if (old_glue > opts.reducetier2glue &&
+             new_glue <= opts.reducetier2glue) {
+    LOG (c, "promoting with new glue %d to tier2", new_glue);
+    stats.promoted2++;
+    c->used = 2;
+  } else if (c->keep)
+    LOG (c, "keeping with new glue %d in tier1", new_glue);
+  else if (old_glue <= opts.reducetier2glue)
+    LOG (c, "keeping with new glue %d in tier2", new_glue);
+  else
+    LOG (c, "keeping with new glue %d in tier3", new_glue);
+  stats.improvedglue++;
+  c->glue = new_glue;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Shrinking a clause, e.g., removing one or more literals, requires to fix
+// the 'pos' field, if it exists and points after the new last literal, has
+// to adjust the global statistics counter of allocated bytes for
+// irredundant clauses, and also adjust the glue value of redundant clauses
+// if the size becomes smaller than the glue.  Also mark the literals in the
+// resulting clause as 'added'.  The result is the number of (aligned)
+// removed bytes, resulting from shrinking the clause.
+//
+size_t Internal::shrink_clause (Clause * c, int new_size) {
+
+  assert (new_size >= 2);
+  assert (new_size < c->size);
+#ifndef NDEBUG
+  for (int i = c->size; i < new_size; i++)
+    c->literals[i] = 0;
+#endif
+
+  if (c->pos >= new_size) c->pos = 2;
+
+  size_t old_bytes = c->bytes ();
+  c->size = new_size;
+  size_t new_bytes = c->bytes ();
+  size_t res = old_bytes - new_bytes;
+
+  if (c->redundant) promote_clause (c, min (c->size-1, c->glue));
+  else if (old_bytes > new_bytes) {
+    assert (stats.irrbytes >= (int64_t) res);
+    stats.irrbytes -= res;
+  }
+
+  if (likely_to_be_kept_clause (c)) mark_added (c);
+
+  return res;
+}
+
+// This is the 'raw' deallocation of a clause.  If the clause is in the
+// arena nothing happens.  If the clause is not in the arena its memory is
+// reclaimed immediately.
+
+void Internal::deallocate_clause (Clause * c) {
+  char * p = (char*) c;
+  if (arena.contains (p)) return;
+  LOG (c, "deallocate pointer %p", (void*) c);
+  delete [] p;
+}
+
+void Internal::delete_clause (Clause * c) {
+  LOG (c, "delete pointer %p", (void*) c);
+  size_t bytes = c->bytes ();
+  stats.collected += bytes;
+  if (c->garbage) {
+    assert (stats.garbage >= (int64_t) bytes);
+    stats.garbage -= bytes;
+
+    // See the discussion in 'propagate' on avoiding to eagerly trace binary
+    // clauses as deleted (produce 'd ...' lines) as soon they are marked
+    // garbage.  We avoid this and only trace them as deleted when they are
+    // actually deleted here.  This allows the solver to propagate binary
+    // garbage clauses without producing incorrect 'd' lines.  The effect
+    // from the proof perspective is that the deletion of these binary
+    // clauses occurs later in the proof file.
+    //
+    if (proof && c->size == 2)
+      proof->delete_clause (c);
+  }
+  deallocate_clause (c);
+}
+
+// We want to eagerly update statistics as soon clauses are marked garbage.
+// Otherwise 'report' for instance gives wrong numbers after 'subsume'
+// before the next 'reduce'.  Thus we factored out marking and accounting
+// for garbage clauses.
+//
+// Eagerly deleting clauses instead is problematic, since references to these
+// clauses need to be flushed, which is too costly to do eagerly.
+//
+// We also update garbage statistics at this point.  This helps to
+// determine whether the garbage collector should be called during for
+// instance bounded variable elimination, which usually generates lots of
+// garbage clauses.
+//
+// In order not to miss any update to these clause statistics we call
+// 'check_clause_stats' after garbage collection in debugging mode.
+//
+void Internal::mark_garbage (Clause * c) {
+
+  assert (!c->garbage);
+
+  // Delay tracing deletion of binary clauses.  See the discussion above in
+  // 'delete_clause' and also in 'propagate'.
+  //
+  if (proof && c->size != 2)
+    proof->delete_clause (c);
+
+  assert (stats.current.total > 0);
+  stats.current.total--;
+
+  size_t bytes = c->bytes ();
+  if (c->redundant) {
+    assert (stats.current.redundant > 0);
+    stats.current.redundant--;
+  } else {
+    assert (stats.current.irredundant > 0);
+    stats.current.irredundant--;
+    assert (stats.irrbytes >= (int64_t) bytes);
+    stats.irrbytes -= bytes;
+    mark_removed (c);
+  }
+  stats.garbage += bytes;
+  c->garbage = true;
+  c->used = 0;
+
+  LOG (c, "marked garbage pointer %p", (void*) c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Almost the same function as 'search_assign' except that we do not pretend
+// to learn a new unit clause (which was confusing in log files).
+
+void Internal::assign_original_unit (int lit) {
+  assert (!level);
+  const int idx = vidx (lit);
+  assert (!vals[idx]);
+  assert (!flags (idx).eliminated ());
+  Var & v = var (idx);
+  v.level = level;
+  v.trail = (int) trail.size ();
+  v.reason = 0;
+  const signed char tmp = sign (lit);
+  vals[idx] = tmp;
+  vals[-idx] = -tmp;
+  assert (val (lit) > 0);
+  assert (val (-lit) < 0);
+  trail.push_back (lit);
+  LOG ("original unit assign %d", lit);
+  mark_fixed (lit);
+  if (propagate ()) return;
+  LOG ("propagation of original unit results in conflict");
+  learn_empty_clause ();
+}
+
+// New clause added through the API, e.g., while parsing a DIMACS file.
+//
+void Internal::add_new_original_clause () {
+  if (level) backtrack ();
+  LOG (original, "original clause");
+  bool skip = false;
+  if (unsat) {
+    LOG ("skipping clause since formula already inconsistent");
+    skip = true;
+  } else {
+    assert (clause.empty ());
+    for (const auto & lit : original) {
+      int tmp = marked (lit);
+      if (tmp > 0) {
+        LOG ("removing duplicated literal %d", lit);
+      } else if (tmp < 0) {
+        LOG ("tautological since both %d and %d occur", -lit, lit);
+        skip = true;
+      } else {
+        mark (lit);
+        tmp = val (lit);
+        if (tmp < 0) {
+          LOG ("removing falsified literal %d", lit);
+        } else if (tmp > 0) {
+          LOG ("satisfied since literal %d true", lit);
+          skip = true;
+        } else {
+          clause.push_back (lit);
+          assert (flags (lit).status != Flags::UNUSED);
+        }
+      }
+    }
+    for (const auto & lit : original)
+      unmark (lit);
+  }
+  if (skip) {
+    if (proof) proof->delete_clause (original);
+  } else {
+    size_t size = clause.size ();
+    if (!size) {
+      if (!unsat) {
+        if (!original.size ()) VERBOSE (1, "found empty original clause");
+        else MSG ("found falsified original clause");
+        unsat = true;
+      }
+    } else if (size == 1) {
+      assign_original_unit (clause[0]);
+    } else {
+      Clause * c = new_clause (false);
+      watch_clause (c);
+    }
+    if (original.size () > size) {
+      external->check_learned_clause ();
+      if (proof) {
+        proof->add_derived_clause (clause);
+        proof->delete_clause (original);
+      }
+    }
+  }
+  clause.clear ();
+}
+
+// Add learned new clause during conflict analysis and watch it. Requires
+// that the clause is at least of size 2, and the first two literals
+// are assigned at the highest decision level.
+//
+Clause * Internal::new_learned_redundant_clause (int glue) {
+  assert (clause.size () > 1);
+#ifndef NDEBUG
+  for (size_t i = 2; i < clause.size (); i++)
+    assert (var (clause[0]).level >= var (clause[i]).level),
+    assert (var (clause[1]).level >= var (clause[i]).level);
+#endif
+  external->check_learned_clause ();
+  Clause * res = new_clause (true, glue);
+  if (proof) proof->add_derived_clause (res);
+  assert (watching ());
+  watch_clause (res);
+  return res;
+}
+
+// Add hyper binary resolved clause during 'probing'.
+//
+Clause * Internal::new_hyper_binary_resolved_clause (bool red, int glue) {
+  external->check_learned_clause ();
+  Clause * res = new_clause (red, glue);
+  if (proof) proof->add_derived_clause (res);
+  assert (watching ());
+  watch_clause (res);
+  return res;
+}
+
+// Add hyper ternary resolved clause during 'ternary'.
+//
+Clause * Internal::new_hyper_ternary_resolved_clause (bool red) {
+  external->check_learned_clause ();
+  size_t size = clause.size ();
+  Clause * res = new_clause (red, size);
+  if (proof) proof->add_derived_clause (res);
+  assert (!watching ());
+  return res;
+}
+
+// Add a new clause with same glue and redundancy as 'orig' but literals are
+// assumed to be in 'clause' in 'decompose' and 'vivify'.
+//
+Clause * Internal::new_clause_as (const Clause * orig) {
+  external->check_learned_clause ();
+  const int new_glue = orig->glue;
+  Clause * res = new_clause (orig->redundant, new_glue);
+  assert (!orig->redundant || !orig->keep || res->keep);
+  if (proof) proof->add_derived_clause (res);
+  assert (watching ());
+  watch_clause (res);
+  return res;
+}
+
+// Add resolved clause during resolution, e.g., bounded variable
+// elimination, but do not connect its occurrences here.
+//
+Clause * Internal::new_resolved_irredundant_clause () {
+  external->check_learned_clause ();
+  Clause * res = new_clause (false);
+  if (proof) proof->add_derived_clause (res);
+  assert (!watching ());
+  return res;
+}
+
+}
diff --git a/hCaD_V2/src/clause.hpp b/hCaD_V2/src/clause.hpp
new file mode 100644
index 0000000..f92e57b
--- /dev/null
+++ b/hCaD_V2/src/clause.hpp
@@ -0,0 +1,151 @@
+#ifndef _clause_hpp_INCLUDED
+#define _clause_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+typedef       int *       literal_iterator;
+typedef const int * const_literal_iterator;
+
+/*------------------------------------------------------------------------*/
+
+// The 'Clause' data structure is very important. There are usually many
+// clauses and accessing them is a hot-spot.  Thus we use common
+// optimizations to reduce memory and improve cache usage, even though this
+// induces some complexity in understanding the code.
+//
+// The most important optimization is to 'embed' the actual literals in the
+// clause.  This requires a variadic size structure and thus strictly is not
+// 'C' conform, but supported by all compilers we used.  The alternative is
+// to store the actual literals somewhere else, which not only needs more
+// memory but more importantly also requires another memory access and thus
+// is very costly.
+
+struct Clause {
+#ifdef LOGGING
+  int64_t id;         // Only useful for debugging.
+#endif
+
+  bool conditioned:1; // Tried for globally blocked clause elimination.
+  bool covered:1;     // Already considered for covered clause elimination.
+  bool enqueued:1;    // Enqueued on backward queue.
+  bool frozen:1;      // Temporarily frozen (in covered clause elimination).
+  bool garbage:1;     // can be garbage collected unless it is a 'reason'
+  bool gate:1 ;       // Clause part of a gate (function definition).
+  bool hyper:1;       // redundant hyper binary or ternary resolved
+  bool instantiated:1;// tried to instantiate
+  bool keep:1;        // always keep this clause (if redundant)
+  bool moved:1;       // moved during garbage collector ('copy' valid)
+  bool reason:1;      // reason / antecedent clause can not be collected
+  bool redundant:1;   // aka 'learned' so not 'irredundant' (original)
+  bool transred:1;    // already checked for transitive reduction
+  bool subsume:1;     // not checked in last subsumption round
+  unsigned used:2;    // resolved in conflict analysis since last 'reduce'
+  bool vivified:1;    // clause already vivified
+  bool vivify:1;      // clause scheduled to be vivified
+
+  // The glucose level ('LBD' or short 'glue') is a heuristic value for the
+  // expected usefulness of a learned clause, where smaller glue is consider
+  // more useful.  During learning the 'glue' is determined as the number of
+  // decisions in the learned clause.  Thus the glue of a clause is a strict
+  // upper limit on the smallest number of decisions needed to make it
+  // propagate.  For instance a binary clause will propagate if one of its
+  // literals is set to false.  Similarly a learned clause with glue 1 can
+  // propagate after one decision, one with glue 2 after 2 decisions etc.
+  // In some sense the glue is an abstraction of the size of the clause.
+  //
+  // See the IJCAI'09 paper by Audemard & Simon for more details.  We
+  // switched back and forth between keeping the glue stored in a clause and
+  // using it only initially to determine whether it is kept, that is
+  // survives clause reduction.  The latter strategy is not bad but also
+  // does not allow to use glue values for instance in 'reduce'.
+  //
+  // More recently we also update the glue and promote clauses to lower
+  // level tiers during conflict analysis.  The idea of using three tiers is
+  // also due to Chanseok Oh and thus used in all recent 'Maple...' solvers.
+  // Tier one are the always kept clauses with low glue at most
+  // 'opts.reducetier1glue' (default '2'). The second tier contains all
+  // clauses with glue larger than 'opts.reducetier1glue' but smaller or
+  // equal than 'opts.reducetier2glue' (default '6').  The third tier
+  // consists of clauses with glue larger than 'opts.reducetier2glue'.
+  //
+  // Clauses in tier one are not deleted in 'reduce'. Clauses in tier
+  // two require to be unused in two consecutive 'reduce' intervals before
+  // being collected while for clauses in tier three not being used since
+  // the last 'reduce' call makes them deletion candidates.  Clauses derived
+  // by hyper binary or ternary resolution (even though small and thus with
+  // low glue) are always removed if they remain unused during one interval.
+  // See 'mark_useless_redundant_clauses_as_garbage' in 'reduce.cpp' and
+  // 'bump_clause' in 'analyze.cpp'.
+  //
+  int glue;
+
+  int size;         // Actual size of 'literals' (at least 2).
+  int pos;          // Position of last watch replacement [Gent'13].
+
+  union {
+
+    int literals[2];    // Of variadic 'size' (shrunken if strengthened).
+
+    Clause * copy;      // Only valid if 'moved', then that's where to.
+    //
+    // The 'copy' field is only valid for 'moved' clauses in the moving
+    // garbage collector 'copy_non_garbage_clauses' for keeping clauses
+    // compactly in a contiguous memory arena.  Otherwise, most of
+    // the time, 'literals' is valid.  See 'collect.cpp' for details.
+  };
+
+  literal_iterator       begin ()       { return literals; }
+  literal_iterator         end ()       { return literals + size; }
+
+  const_literal_iterator begin () const { return literals; }
+  const_literal_iterator   end () const { return literals + size; }
+
+  static size_t bytes (int size) {
+
+    // Memory sanitizer insists that clauses put into consecutive memory in
+    // the arena are still 8 byte aligned.  We could also allocate 8 byte
+    // aligned memory there.  However, assuming the real memory foot print
+    // of a clause is 8 bytes anyhow, we just allocate 8 byte aligned memory
+    // all the time (even if allocated outside of the arena).
+    //
+    assert (size > 1);
+    return align ((size - 2) * sizeof (int) + sizeof (Clause), 8);
+  }
+
+  size_t bytes () const { return bytes (size); }
+
+  // Check whether this clause is ready to be collected and deleted.  The
+  // 'reason' flag is only there to protect reason clauses in 'reduce',
+  // which does not backtrack to the root level.  If garbage collection is
+  // triggered from a preprocessor, which backtracks to the root level, then
+  // 'reason' is false for sure. We want to use the same garbage collection
+  // code though for both situations and thus hide here this variance.
+  //
+  bool collect () const { return !reason && garbage; }
+};
+
+struct clause_smaller_size {
+  bool operator () (const Clause * a, const Clause * b) {
+    return a->size < b->size;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Place literals over the same variable close to each other.  This would
+// allow eager removal of identical literals and detection of tautological
+// clauses but is only currently used for better logging (see also
+// 'opts.logsort' in 'logging.cpp').
+
+struct clause_lit_less_than {
+  bool operator () (int a, int b) const {
+    int s = abs (a), t = abs (b);
+    return s < t || (s == t && a < b);
+  }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/collect.cpp b/hCaD_V2/src/collect.cpp
new file mode 100644
index 0000000..4e0a4a2
--- /dev/null
+++ b/hCaD_V2/src/collect.cpp
@@ -0,0 +1,429 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Returns the positive number '1' ( > 0) if the given clause is root level
+// satisfied or the negative number '-1' ( < 0) if it is not root level
+// satisfied but contains a root level falsified literal. Otherwise, if it
+// contains neither a satisfied nor falsified literal, then '0' is returned.
+
+int Internal::clause_contains_fixed_literal (Clause * c) {
+  int satisfied = 0, falsified = 0;
+  for (const auto & lit : *c) {
+    const int tmp = fixed (lit);
+    if (tmp > 0) {
+      LOG (c, "root level satisfied literal %d in", lit);
+      satisfied++;
+    }
+    if (tmp < 0) {
+      LOG (c, "root level falsified literal %d in", lit);
+      falsified++;
+    }
+  }
+       if (satisfied) return 1;
+  else if (falsified) return -1;
+  else                return 0;
+}
+
+// Assume that the clause is not root level satisfied but contains a literal
+// set to false (root level falsified literal), so it can be shrunken.  The
+// clause data is not actually reallocated at this point to avoid dealing
+// with issues of special policies for watching binary clauses or whether a
+// clause is extended or not. Only its size field is adjusted accordingly
+// after flushing out root level falsified literals.
+
+void Internal::remove_falsified_literals (Clause * c) {
+  const const_literal_iterator end = c->end ();
+  const_literal_iterator i;
+  int num_non_false = 0;
+  for (i = c->begin (); num_non_false < 2 && i != end; i++)
+    if (fixed (*i) >= 0) num_non_false++;
+  if (num_non_false < 2) return;
+  if (proof) proof->flush_clause (c);
+  literal_iterator j = c->begin ();
+  for (i = j; i != end; i++) {
+    const int lit = *j++ = *i, tmp = fixed (lit);
+    assert (tmp <= 0);
+    if (tmp >= 0) continue;
+    LOG ("flushing %d", lit);
+    j--;
+  }
+  stats.collected += shrink_clause (c, j - c->begin ());
+}
+
+// If there are new units (fixed variables) since the last garbage
+// collection we go over all clauses, mark satisfied ones as garbage and
+// flush falsified literals.  Otherwise if no new units have been generated
+// since the last garbage collection just skip this step.
+
+void Internal::mark_satisfied_clauses_as_garbage () {
+
+  if (last.collect.fixed >= stats.all.fixed) return;
+  last.collect.fixed = stats.all.fixed;
+
+  LOG ("marking satisfied clauses and removing falsified literals");
+
+  for (const auto & c : clauses) {
+    if (c->garbage) continue;
+    const int tmp = clause_contains_fixed_literal (c);
+         if (tmp > 0) mark_garbage (c);
+    else if (tmp < 0) remove_falsified_literals (c);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Reason clauses can not be collected.
+//
+// We protect reasons before and release protection after garbage collection
+// (actually within garbage collection).
+//
+// For 'reduce' we still need to make sure that all clauses which should not
+// be removed are marked as such and thus we need to call it before marking
+// clauses to be flushed.
+
+void Internal::protect_reasons () {
+  LOG ("protecting reason clauses of all assigned variables on trail");
+  assert (!protected_reasons);
+  size_t count = 0;
+  for (const auto & lit : trail) {
+    if (!active (lit)) continue;
+    assert (val (lit));
+    Var & v = var (lit);
+    assert (v.level > 0);
+    Clause * reason = v.reason;
+    if (!reason) continue;
+    LOG (reason, "protecting assigned %d reason %p", lit, (void*) reason);
+    assert (!reason->reason);
+    reason->reason = true;
+    count++;
+  }
+  LOG ("protected %zd reason clauses referenced on trail", count);
+  protected_reasons = true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// After garbage collection we reset the 'reason' flag of the reasons
+// of assigned literals on the trail.
+
+void Internal::unprotect_reasons () {
+  LOG ("unprotecting reasons clauses of all assigned variables on trail");
+  assert (protected_reasons);
+  size_t count = 0;
+  for (const auto & lit : trail) {
+    if (!active (lit)) continue;
+    assert (val (lit));
+    Var & v = var (lit);
+    assert (v.level > 0);
+    Clause * reason = v.reason;
+    if (!reason) continue;
+    LOG (reason, "unprotecting assigned %d reason %p", lit, (void*) reason);
+    assert (reason->reason);
+    reason->reason = false;
+    count++;
+  }
+  LOG ("unprotected %zd reason clauses referenced on trail", count);
+  protected_reasons = false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Update occurrence lists before deleting garbage clauses in the context of
+// preprocessing, e.g., during bounded variable elimination 'elim'.  The
+// result is the number of remaining clauses, which in this context means
+// the number of non-garbage clauses.
+
+size_t Internal::flush_occs (int lit) {
+  Occs & os = occs (lit);
+  const const_occs_iterator end = os.end ();
+  occs_iterator j = os.begin ();
+  const_occs_iterator i;
+  size_t res = 0;
+  Clause * c;
+  for (i = j; i != end; i++) {
+    c = *i;
+    if (c->collect ()) continue;
+    *j++ = c->moved ? c->copy : c;
+    assert (!c->redundant);
+    res++;
+  }
+  os.resize (j - os.begin ());
+  shrink_occs (os);
+  return res;
+}
+
+// Update watch lists before deleting garbage clauses in the context of
+// 'reduce' where we watch and no occurrence lists.  We have to protect
+// reason clauses not be collected and thus we have this additional check
+// hidden in 'Clause.collect', which for the root level context of
+// preprocessing is actually redundant.
+
+inline void Internal::flush_watches (int lit, Watches & saved) {
+  assert (saved.empty ());
+  Watches & ws = watches (lit);
+  const const_watch_iterator end = ws.end ();
+  watch_iterator j = ws.begin ();
+  const_watch_iterator i;
+  for (i = j; i != end; i++) {
+    Watch w = *i;
+    Clause * c = w.clause;
+    if (c->collect ()) continue;
+    if (c->moved) c = w.clause = c->copy;
+    w.size = c->size;
+    const int new_blit_pos = (c->literals[0] == lit);
+    assert (c->literals[!new_blit_pos] == lit);        /*FW1*/
+    w.blit = c->literals[new_blit_pos];
+    if (w.binary ()) *j++ = w;
+    else saved.push_back (w);
+  }
+  ws.resize (j - ws.begin ());
+  for (const auto & w : saved) ws.push_back (w);
+  saved.clear ();
+  shrink_vector (ws);
+}
+
+void Internal::flush_all_occs_and_watches () {
+  if (occurring ())
+    for (auto idx : vars)
+      flush_occs (idx), flush_occs (-idx);
+
+  if (watching ()) {
+    Watches tmp;
+    for (auto idx : vars)
+      flush_watches (idx, tmp), flush_watches (-idx, tmp);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::update_reason_references () {
+  LOG ("update assigned reason references");
+  size_t count = 0;
+  for (auto & lit : trail) {
+    if (!active (lit)) continue;
+    Var & v = var (lit);
+    Clause * c = v.reason;
+    if (!c) continue;
+    LOG (c, "updating assigned %d reason", lit);
+    assert (c->reason);
+    assert (c->moved);
+    Clause * d = c->copy;
+    v.reason = d;
+    count++;
+  }
+  LOG ("updated %zd assigned reason references", count);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is a simple garbage collector which does not move clauses.  It needs
+// less space than the arena based clause allocator, but is not as cache
+// efficient, since the copying garbage collector can put clauses together
+// which are likely accessed after each other.
+
+void Internal::delete_garbage_clauses () {
+
+  flush_all_occs_and_watches ();
+
+  LOG ("deleting garbage clauses");
+  int64_t collected_bytes = 0, collected_clauses = 0;
+  const auto end = clauses.end ();
+  auto j = clauses.begin (), i = j;
+  while (i != end) {
+    Clause * c = *j++ = *i++;
+    if (!c->collect ()) continue;
+    collected_bytes += c->bytes ();
+    collected_clauses++;
+    delete_clause (c);
+    j--;
+  }
+  clauses.resize (j - clauses.begin ());
+  shrink_vector (clauses);
+
+  PHASE ("collect", stats.collections,
+    "collected %" PRId64 " bytes of %" PRId64 " garbage clauses",
+    collected_bytes, collected_clauses);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the start of the copying garbage collector using the arena.  At
+// the core is the following function, which copies a clause to the 'to'
+// space of the arena.  Be careful if this clause is a reason of an
+// assignment.  In that case update the reason reference.
+//
+void Internal::copy_clause (Clause * c) {
+  LOG (c, "moving");
+  assert (!c->moved);
+  char * p = (char*) c;
+  char * q = arena.copy (p, c->bytes ());
+  c->copy = (Clause *) q;
+  c->moved = true;
+  LOG ("copied clause[%" PRId64 "] from %p to %p",
+       c->id, (void*) c, (void*) c->copy);
+}
+
+// This is the moving garbage collector.
+
+void Internal::copy_non_garbage_clauses () {
+
+  size_t collected_clauses = 0, collected_bytes = 0;
+  size_t     moved_clauses = 0,     moved_bytes = 0;
+
+  // First determine 'moved_bytes' and 'collected_bytes'.
+  //
+  for (const auto & c : clauses)
+    if (!c->collect ()) moved_bytes += c->bytes (), moved_clauses++;
+    else collected_bytes += c->bytes (), collected_clauses++;
+
+  PHASE ("collect", stats.collections,
+    "moving %zd bytes %.0f%% of %zd non garbage clauses",
+    moved_bytes,
+    percent (moved_bytes, collected_bytes + moved_bytes),
+    moved_clauses);
+
+  // Prepare 'to' space of size 'moved_bytes'.
+  //
+  arena.prepare (moved_bytes);
+
+  // Keep clauses in arena in the same order.
+  //
+  if (opts.arenacompact)
+    for (const auto & c : clauses)
+      if (!c->collect () && arena.contains (c))
+        copy_clause (c);
+
+  if (opts.arenatype == 1 || !watching ()) {
+
+    // Localize according to current clause order.
+
+    // If the option 'opts.arenatype == 1' is set, then this means the
+    // solver uses the original order of clauses.  If there are no watches,
+    // we can not use the watched based copying policies below.  This
+    // happens if garbage collection is triggered during bounded variable
+    // elimination.
+
+    // Copy clauses according to the order of calling 'copy_clause', which
+    // in essence just gives a compacting garbage collector, since their
+    // relative order is kept, and actually already gives the largest
+    // benefit due to better cache locality.
+
+    for (const auto & c : clauses)
+      if (!c->moved && !c->collect ())
+        copy_clause (c);
+
+  } else if (opts.arenatype == 2) {
+
+    // Localize according to (original) variable order.
+
+    // This is almost the version used by MiniSAT and descendants.
+    // Our version uses saved phases too.
+
+    for (int sign = -1; sign <= 1; sign += 2)
+      for (auto idx : vars)
+        for (const auto & w : watches (sign * likely_phase (idx)))
+          if (!w.clause->moved && !w.clause->collect ())
+            copy_clause (w.clause);
+
+  } else {
+
+    // Localize according to decision queue order.
+
+    // This is the default for search. It allocates clauses in the order of
+    // the decision queue and also uses saved phases.  It seems faster than
+    // the MiniSAT version and thus we keep 'opts.arenatype == 3'.
+
+    assert (opts.arenatype == 3);
+
+    for (int sign = -1; sign <= 1; sign += 2)
+      for (int idx = queue.last; idx; idx = link (idx).prev)
+        for (const auto & w : watches (sign * likely_phase (idx)))
+          if (!w.clause->moved && !w.clause->collect ())
+            copy_clause (w.clause);
+  }
+
+  // Do not forget to move clauses which are not watched, which happened in
+  // a rare situation, and now is only left as defensive code.
+  //
+  for (const auto & c : clauses)
+    if (!c->collect () && !c->moved)
+      copy_clause (c);
+
+  flush_all_occs_and_watches ();
+  update_reason_references ();
+
+  // Replace and flush clause references in 'clauses'.
+  //
+  const auto end = clauses.end ();
+  auto j = clauses.begin (), i = j;
+  for (; i != end; i++) {
+    Clause * c = *i;
+    if (c->collect ()) delete_clause (c);
+    else assert (c->moved), *j++ = c->copy, deallocate_clause (c);
+  }
+  clauses.resize (j - clauses.begin ());
+  if (clauses.size () < clauses.capacity ()/2) shrink_vector (clauses);
+
+  if (opts.arenasort)
+    rsort (clauses.begin (), clauses.end (), pointer_rank ());
+
+  // Release 'from' space completely and then swap 'to' with 'from'.
+  //
+  arena.swap ();
+
+  PHASE ("collect", stats.collections,
+    "collected %zd bytes %.0f%% of %zd garbage clauses",
+    collected_bytes,
+    percent (collected_bytes, collected_bytes + moved_bytes),
+    collected_clauses);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Maintaining clause statistics is complex and error prone but necessary
+// for proper scheduling of garbage collection, particularly during bounded
+// variable elimination.  With this function we can check whether these
+// statistics are updated correctly.
+
+void Internal::check_clause_stats () {
+#ifndef NDEBUG
+  int64_t irredundant = 0, redundant = 0, total = 0, irrbytes = 0;
+  for (const auto & c : clauses) {
+    if (c->garbage) continue;
+    if (c->redundant) redundant++; else irredundant++;
+    if (!c->redundant) irrbytes += c->bytes ();
+    total++;
+  }
+  assert (stats.current.irredundant == irredundant);
+  assert (stats.current.redundant == redundant);
+  assert (stats.current.total == total);
+  assert (stats.irrbytes == irrbytes);
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::arenaing () {
+  return opts.arena && (stats.collections > 1);
+}
+
+void Internal::garbage_collection () {
+  if (unsat) return;
+  START (collect);
+  report ('G', 1);
+  stats.collections++;
+  mark_satisfied_clauses_as_garbage ();
+  if (!protected_reasons) protect_reasons ();
+  if (arenaing ()) copy_non_garbage_clauses ();
+  else delete_garbage_clauses ();
+  check_clause_stats ();
+  check_var_stats ();
+  unprotect_reasons ();
+  report ('C', 1);
+  STOP (collect);
+}
+
+}
diff --git a/hCaD_V2/src/compact.cpp b/hCaD_V2/src/compact.cpp
new file mode 100644
index 0000000..4a2cc05
--- /dev/null
+++ b/hCaD_V2/src/compact.cpp
@@ -0,0 +1,416 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Compacting removes holes generated by inactive variables (fixed,
+// eliminated, substituted or pure) by mapping active variables indices down
+// to a contiguous interval of indices.
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::compacting () {
+  if (level) return false;
+  if (!opts.compact) return false;
+  if (stats.conflicts < lim.compact) return false;
+  int inactive = max_var - active ();
+  assert (inactive >= 0);
+  if (!inactive) return false;
+  if (inactive < opts.compactmin) return false;
+  return inactive >= (1e-3 * opts.compactlim) * max_var;
+}
+
+/*------------------------------------------------------------------------*/
+
+struct Mapper {
+
+  Internal * internal;
+  int new_max_var;              // New 'max_var' after compacting.
+  int * table;                  // Old variable index to new literal map.
+  int first_fixed;              // First fixed variable index.
+  int map_first_fixed;          // Mapped literal of first fixed variable.
+  signed char first_fixed_val;  // Value of first fixed variable.
+  size_t new_vsize;
+
+  /*----------------------------------------------------------------------*/
+  // We produce a compacting garbage collector like map of old 'src' to
+  // new 'dst' variables.  Inactive variables are just skipped except for
+  // fixed ones which will be mapped to the first fixed variable (in the
+  // appropriate phase).  This avoids to handle the case 'fixed value'
+  // separately as it is done in Lingeling, where fixed variables are
+  // mapped to the internal variable '1'.
+  //
+  Mapper (Internal * i) :
+    internal (i),
+    new_max_var (0),
+    first_fixed (0),
+    map_first_fixed (0),
+    first_fixed_val (0)
+  {
+    table = new int [ internal->max_var + 1u ];
+    clear_n (table, internal->max_var + 1u);
+
+    assert (!internal->level);
+
+    for (auto src : internal->vars) {
+      const Flags & f = internal->flags (src);
+      if (f.active ()) table[src] = ++new_max_var;
+      else if (f.fixed () && !first_fixed)
+        table[first_fixed = src] = map_first_fixed = ++new_max_var;
+    }
+
+    first_fixed_val = first_fixed ? internal->val (first_fixed) : 0;
+    new_vsize = new_max_var + 1u;
+  }
+
+  ~Mapper () { delete [] table; }
+
+  /*----------------------------------------------------------------------*/
+  // Map old variable indices.  A result of zero means not mapped.
+  //
+  int map_idx (int src) {
+    assert (0 < src);
+    assert (src <= internal->max_var);
+    const int res = table[src];
+    assert (res <= new_max_var);
+    return res;
+  }
+
+  /*----------------------------------------------------------------------*/
+  // The 'map_idx' above is just a look-up into the 'table'.  Here we have
+  // to care about signedness of 'src', and in addition that fixed variables
+  // have all to be mapped to the first fixed variable 'first_fixed'.
+  //
+  int map_lit (int src) {
+    int res = map_idx (abs (src));
+    if (!res) {
+      const signed char tmp = internal->val (src);
+      if (tmp) {
+        assert (first_fixed);
+        res = map_first_fixed;
+        if (tmp != first_fixed_val) res = -res;
+      }
+    } else if ((src) < 0) res = -res;
+    assert (abs (res) <= new_max_var);
+    return res;
+  }
+
+  /*----------------------------------------------------------------------*/
+  // Map positive variable indices in vector.
+  //
+  template<class T>
+  void map_vector (vector<T> & v) {
+    for (auto src : internal->vars) {
+      const int dst = map_idx (src);
+      if (!dst) continue;
+      assert (0 < dst);
+      assert (dst <= src);
+      v[dst] = v[src];
+    }
+    v.resize (new_vsize);
+    shrink_vector (v);
+  }
+
+  /*----------------------------------------------------------------------*/
+  // Map positive and negative variable indices in two-sided vector.
+  //
+  template<class T>
+  void map2_vector (vector<T> & v) {
+    for (auto src : internal->vars) {
+      const int dst = map_idx (src);
+      if (!dst) continue;
+      assert (0 < dst);
+      assert (dst <= src);
+      v[2*dst] = v[2*src];
+      v[2*dst + 1] = v[2*src + 1];
+    }
+    v.resize (2*new_vsize);
+    shrink_vector (v);
+  }
+
+  /*----------------------------------------------------------------------*/
+  // Map a vector of literals, flush inactive literals, then resize and
+  // shrink it to fit the new size after flushing.
+  //
+  void map_flush_and_shrink_lits (vector<int> & v) {
+    const auto end = v.end ();
+    auto j = v.begin (), i = j;
+    for (; i != end; i++) {
+      const int src = *i;
+      int dst = map_idx (abs (src));
+      assert (abs (dst) <= abs (src));
+      if (!dst) continue;
+      if (src < 0) dst = -dst;
+      *j++ = dst;
+    }
+    v.resize (j - v.begin ());
+    shrink_vector (v);
+  }
+
+};
+
+/*------------------------------------------------------------------------*/
+
+static signed char * ignore_clang_analyze_memory_leak_warning;
+
+void Internal::compact () {
+
+  START (compact);
+
+  assert (active () < max_var);
+
+  stats.compacts++;
+
+  assert (!level);
+  assert (!unsat);
+  assert (!conflict);
+  assert (clause.empty ());
+  assert (levels.empty ());
+  assert (analyzed.empty ());
+  assert (minimized.empty ());
+  assert (control.size () == 1);
+  assert (propagated == trail.size ());
+
+  garbage_collection ();
+
+  Mapper mapper (this);
+
+  if (mapper.first_fixed)
+    LOG ("found first fixed %d",
+      sign (mapper.first_fixed_val)*mapper.first_fixed);
+  else LOG ("no variable fixed");
+
+  if (!assumptions.empty ()) {
+    assert (!external->assumptions.empty ());
+    LOG ("temporarily reset internal assumptions");
+    reset_assumptions ();
+  }
+
+  /*======================================================================*/
+  // In this first part we only map stuff without reallocation / shrinking.
+  /*======================================================================*/
+
+  // Flush the external indices.  This has to occur before we map 'vals'.
+  //
+  for (auto eidx : external->vars) {
+    int src = external->e2i[eidx];
+    if (!src) continue;
+    int dst = mapper.map_lit (src);
+    LOG ("compact %" PRId64 " maps external %d to internal %d from internal %d",
+      stats.compacts, eidx, dst, src);
+    external->e2i[eidx] = dst;
+  }
+
+  // Map the literals in all clauses.
+  //
+  for (const auto & c : clauses) {
+    assert (!c->garbage);
+    for (auto & src : *c) {
+      assert (!val (src));
+      int dst;
+      dst = mapper.map_lit (src);
+      assert (dst || c->garbage);
+      src = dst;
+    }
+  }
+
+  // Map the blocking literals in all watches.
+  //
+  if (!wtab.empty ())
+    for (auto lit : lits)
+      for (auto & w : watches (lit))
+        w.blit = mapper.map_lit (w.blit);
+
+  // We first flush inactive variables and map the links in the queue.  This
+  // has to be done before we map the actual links data structure 'links'.
+  {
+    int prev = 0, mapped_prev = 0, next;
+    for (int idx = queue.first; idx; idx = next) {
+      next = links[idx].next;
+      if (idx == mapper.first_fixed) continue;
+      const int dst = mapper.map_idx (idx);
+      if (!dst) continue;
+      assert (active (idx));
+      if (prev) links[prev].next = dst; else queue.first = dst;
+      links[idx].prev = mapped_prev;
+      mapped_prev = dst;
+      prev = idx;
+    }
+    if (prev) links[prev].next = 0; else queue.first = 0;
+    queue.unassigned = queue.last = mapped_prev;
+  }
+
+  /*======================================================================*/
+  // In the second part we map, flush and shrink arrays.
+  /*======================================================================*/
+
+  mapper.map_flush_and_shrink_lits (trail);
+  propagated = trail.size ();
+  if (mapper.first_fixed) {
+    assert (trail.size () == 1);
+    var (mapper.first_fixed).trail = 0;            // before mapping 'vtab'
+  } else assert (trail.empty ());
+
+  if (!probes.empty ())
+    mapper.map_flush_and_shrink_lits (probes);
+
+  /*======================================================================*/
+  // In the third part we map stuff and also reallocate memory.
+  /*======================================================================*/
+
+  // Now we continue in reverse order of allocated bytes, e.g., see
+  // 'Internal::enlarge' which reallocates in order of allocated bytes.
+
+  mapper.map_vector (ftab);
+  mapper.map_vector (parents);
+  mapper.map_vector (marks);
+  mapper.map_vector (phases.saved);
+  mapper.map_vector (phases.forced);
+  mapper.map_vector (phases.target);
+  mapper.map_vector (phases.best);
+  mapper.map_vector (phases.prev);
+  mapper.map_vector (phases.min);
+  
+  if(opts.psids) mapper.map2_vector(phases.act);
+  // Special code for 'frozentab'.
+  //
+  for (auto src : vars) {
+    const int dst = mapper.map_idx (src);
+    if (!dst) continue;
+    if (src == dst) continue;
+    assert (dst < src);
+    frozentab[dst] += frozentab[src];
+    frozentab[src] = 0;
+  }
+  frozentab.resize (mapper.new_vsize);
+  shrink_vector (frozentab);
+
+  /*----------------------------------------------------------------------*/
+
+  if (!external->assumptions.empty ()) {
+
+    for (const auto & elit : external->assumptions) {
+      assert (elit);
+      assert (elit != INT_MIN);
+      int eidx = abs (elit);
+      assert (eidx <= external->max_var);
+      int ilit = external->e2i[eidx];
+      assert (ilit);            // Because we froze all!!!
+      if (elit < 0) ilit = -ilit;
+      assume (ilit);
+    }
+
+    PHASE ("compact", stats.compacts,
+      "reassumed %zd external assumptions",
+      external->assumptions.size ());
+  }
+
+  // Special case for 'val' as for 'val' we trade branch less code for
+  // memory and always allocated an [-maxvar,...,maxvar] array.
+  {
+    signed char * new_vals = new signed char [ 2*mapper.new_vsize ];
+    ignore_clang_analyze_memory_leak_warning = new_vals;
+    new_vals += mapper.new_vsize;
+    for (auto src : vars)
+      new_vals[-mapper.map_idx (src)] = vals[-src];
+    for (auto src : vars)
+      new_vals[mapper.map_idx (src)] = vals[src];
+    new_vals[0] = 0;
+    vals -= vsize;
+    delete [] vals;
+    vals = new_vals;
+  }
+
+  mapper.map_vector (i2e);
+  mapper.map2_vector (ptab);
+  mapper.map_vector (btab);
+  mapper.map_vector (gtab);
+  mapper.map_vector (links);
+  mapper.map_vector (vtab);
+  if (!ntab.empty ()) mapper.map2_vector (ntab);
+  if (!wtab.empty ()) mapper.map2_vector (wtab);
+  if (!otab.empty ()) mapper.map2_vector (otab);
+  if (!big.empty ()) mapper.map2_vector (big);
+
+  /*======================================================================*/
+  // In the fourth part we map the binary heap for scores.
+  /*======================================================================*/
+
+  // The simplest way to map a binary heap is to get all elements from the
+  // heap and reinsert them.  This could be slightly improved in terms of
+  // speed if we add a 'flush (int * map)' function to 'Heap', but that is
+  // pretty complicated and would require that the 'Heap' knows that mapped
+  // elements with 'zero' destination should be flushed.
+
+  vector<int> saved;
+  assert (saved.empty ());
+  if (!scores.empty ()) {
+    while (!scores.empty ()) {
+      const int src = scores.front ();
+      scores.pop_front ();
+      const int dst = mapper.map_idx (src);
+      if (!dst) continue;
+      if (src == mapper.first_fixed) continue;
+      saved.push_back (dst);
+    }
+    scores.erase ();
+  }
+  mapper.map_vector (stab);
+  if (!saved.empty ()) {
+    for (const auto & idx : saved)
+      scores.push_back (idx);
+    scores.shrink ();
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  PHASE ("compact", stats.compacts,
+    "reducing internal variables from %d to %d",
+    max_var, mapper.new_max_var);
+
+  /*----------------------------------------------------------------------*/
+
+  // Need to adjust the target and best assigned counters too.
+
+  size_t new_target_assigned = 0, new_best_assigned = 0;
+
+  for (auto idx : Range (mapper.new_max_var)) {
+    if (phases.target[idx]) new_target_assigned++;
+    if (phases.best[idx]) new_best_assigned++;
+  }
+
+  LOG ("reset target assigned from %zd to %zd",
+    target_assigned, new_target_assigned);
+  LOG ("reset best assigned from %zd to %zd",
+    best_assigned, new_best_assigned);
+
+  target_assigned = new_target_assigned;
+  best_assigned = new_best_assigned;
+  no_conflict_until = 0;
+
+  INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
+  INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
+
+  /*----------------------------------------------------------------------*/
+
+  max_var = mapper.new_max_var;
+  vsize = mapper.new_vsize;
+
+  stats.unused = 0;
+  stats.inactive = stats.now.fixed = mapper.first_fixed ? 1 : 0;
+  stats.now.substituted = stats.now.eliminated = stats.now.pure = 0;
+
+  check_var_stats ();
+
+  int64_t delta = opts.compactint * (stats.compacts + 1);
+  lim.compact = stats.conflicts + delta;
+
+  PHASE ("compact", stats.compacts,
+    "new compact limit %" PRId64 " after %" PRId64 " conflicts",
+    lim.compact, delta);
+
+  STOP (compact);
+}
+
+}
diff --git a/hCaD_V2/src/condition.cpp b/hCaD_V2/src/condition.cpp
new file mode 100644
index 0000000..6d7b91a
--- /dev/null
+++ b/hCaD_V2/src/condition.cpp
@@ -0,0 +1,898 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Globally blocked clause elimination (which we call here 'conditioning')
+// is described first in the PhD thesis of Benjamin Kiesl from 2019.  An
+// extended version, which in particular describes the algorithm implemented
+// below is in our invited ATVA'19 paper [KieslHeuleBiere-ATVA'19].  This
+// accordingly needs witnesses consisting potentially of more than one
+// literal.  It is the first technique implemented in CaDiCaL with this
+// feature (PR clause elimination thus should work in principle too).
+
+// Basically globally blocked clauses are like set blocked clauses, except
+// that the witness cube (of literals to be flipped during reconstruction)
+// can contain variables which are not in the blocked clause.  This
+// can simulate some interesting global optimizations like 'headlines' from
+// the FAN algorithm for ATPG.  The technique was actually motivated to
+// simulate this optimization.  It turns out that globally blocked clauses
+// can be seen as 'conditional autarkies', where in essence the condition
+// cube is the negation of the globally blocked redundant clause (it
+// needs to contain one autarky literal though) and the autarky part
+// represents the witness.
+
+/*------------------------------------------------------------------------*/
+
+// Elimination of globally blocked clauses is first tried in regular
+// intervals in terms of the number of conflicts.  Then the main heuristics
+// is to trigger 'condition' if the decision level is above the current
+// moving average of the back jump level.
+
+// TODO We might need to consider less frequent conditioning.
+
+bool Internal::conditioning () {
+
+  if (!opts.condition) return false;
+  if (!preprocessing && !opts.inprocessing) return false;
+  if (preprocessing) assert (lim.preprocessing);
+
+  // Triggered in regular 'opts.conditionint' conflict intervals.
+  //
+  if (lim.condition > stats.conflicts) return false;
+
+  if (!level) return false;                     // One decision necessary.
+
+  if (level <= averages.current.jump) return false;     // Main heuristic.
+
+  if (!stats.current.irredundant) return false;
+  double remain = active ();
+  if (!remain) return false;
+  double ratio = stats.current.irredundant / remain;
+  return ratio <= opts.conditionmaxrat;
+}
+
+/*------------------------------------------------------------------------*/
+
+// We start with the current assignment and then temporarily unassign
+// literals.  They are reassigned afterwards.  The global state of the CDCL
+// solver should not change though.  Thus we copied from 'search_unassign'
+// in 'backtrack.cpp' what is needed to unassign literals and then from
+// 'search_assign' in 'propagate.cpp' what is needed for reassigning
+// literals, but restricted the copied code to only updating the actual
+// assignment (in 'vals') and not changing anything else.
+
+// We use temporarily unassigning for two purposes.  First, if a conditional
+// literal does not occur negated in a candidate clause it is unassigned.
+// Second, as a minor optimization, we first unassign all root-level
+// assigned (fixed) literals, to avoid checking the decision level of
+// literals during the procedure.
+
+void Internal::condition_unassign (int lit) {
+  LOG ("condition unassign %d", lit);
+  assert (val (lit) > 0);
+  vals[lit] = vals[-lit] = 0;
+}
+
+void Internal::condition_assign (int lit) {
+  LOG ("condition assign %d", lit);
+  assert (!val (lit));
+  vals[lit] = 1;
+  vals[-lit] = -1;
+  assert (val (lit) > 0);
+  assert (val (-lit) < 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+// The current partition into conditional part and autarky part during
+// refinement is represented through a conditional bit in 'marks'.
+
+inline bool Internal::is_conditional_literal (int lit) const {
+  return val (lit) > 0 && getbit (lit, 0);
+}
+
+inline bool Internal::is_autarky_literal (int lit) const {
+  return val (lit) > 0 && !getbit (lit, 0);
+}
+
+inline void Internal::mark_as_conditional_literal (int lit) {
+  LOG ("marking %d as conditional literal", lit);
+  assert (val (lit) > 0);
+  setbit (lit, 0);
+  assert (is_conditional_literal (lit));
+  assert (!is_autarky_literal (lit));
+}
+
+inline void Internal::unmark_as_conditional_literal (int lit) {
+  LOG ("unmarking %d as conditional literal", lit);
+  assert (is_conditional_literal (lit));
+  unsetbit (lit, 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+// We also need to know the literals which are in the current clause.  These
+// are just marked (also in 'marks' but with the (signed) upper two bits).
+// We need a signed mark here, since we have to distinguish positive and
+// negative occurrences of literals in the candidate clause.
+
+inline bool Internal::is_in_candidate_clause (int lit) const {
+  return marked67 (lit) > 0;
+}
+
+inline void Internal::mark_in_candidate_clause (int lit) {
+  LOG ("marking %d as literal of the candidate clause", lit);
+  mark67 (lit);
+  assert (is_in_candidate_clause (lit));
+  assert (!is_in_candidate_clause (-lit));
+}
+
+inline void Internal::unmark_in_candidate_clause (int lit) {
+  LOG ("unmarking %d as literal of the candidate clause", lit);
+  assert (is_in_candidate_clause (lit));
+  unmark67 (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+struct less_conditioned {
+  bool operator () (Clause * a, Clause * b) {
+    return !a->conditioned && b->conditioned;
+  }
+};
+
+// This is the function for eliminating globally blocked clauses.  It is
+// triggered during CDCL search according to 'conditioning' above and uses
+// the current assignment as basis to find globally blocked clauses.
+
+long Internal::condition_round (long delta) {
+
+  long limit, props = 0;
+  if (LONG_MAX - delta < stats.condprops) limit = LONG_MAX;
+  else limit = stats.condprops + delta;
+
+  size_t initial_trail_level = trail.size ();
+  int initial_level = level;
+
+  LOG ("initial trail level %zd", initial_trail_level);
+
+  protect_reasons ();
+
+#if defined(LOGGING) || !defined(NDEBUG)
+  int additionally_assigned = 0;
+#endif
+
+  for (auto idx : vars) {
+    const signed char tmp = val (idx);
+    Var & v = var (idx);
+    if (tmp) {
+      if (v.level) {
+        const int lit = tmp < 0 ? -idx : idx;
+        if (!active (idx)) {
+          LOG ("temporarily unassigning inactive literal %d", lit);
+          condition_unassign (lit);
+        } if (frozen (idx)) {
+          LOG ("temporarily unassigning frozen literal %d", lit);
+          condition_unassign (lit);
+        }
+      }
+    } else if (frozen (idx)) {
+      LOG ("keeping frozen literal %d unassigned", idx);
+    } else if (!active (idx)) {
+      LOG ("keeping inactive literal %d unassigned", idx);
+    } else { // if (preprocessing) {
+      if (initial_level == level) {
+        level++;
+        LOG ("new condition decision level");
+      }
+      const int lit = decide_phase (idx, true);
+      condition_assign (lit);
+      v.level = level;
+      trail.push_back (lit);
+#if defined(LOGGING) || !defined(NDEBUG)
+      additionally_assigned++;
+#endif
+    }
+  }
+  LOG ("assigned %d additional literals", additionally_assigned);
+
+  // We compute statistics about the size of the assignments.
+  //
+  // The initial assignment consists of the non-root-level assigned literals
+  // split into a conditional and an autarky part.  The conditional part
+  // consists of literals assigned true and occurring negated in a clause
+  // (touch the clause), which does not contain another literal assigned to
+  // true.  This initial partition is the same for all refinements used in
+  // checking whether a candidate clause is globally blocked.
+  //
+  // For each candidate clause some of the conditional literals have to be
+  // unassigned, and the autarky is shrunken by turning some of the autarky
+  // literals into conditional literals (which might get unassigned in a
+  // later refinement though).
+  //
+  // The fix-point of this procedure produces a final assignment, which
+  // consists of the remaining assigned literals, again split into a
+  // conditional and an autarky part.
+  //
+  struct { size_t assigned, conditional, autarky; } initial, remain;
+
+  initial.assigned = 0;
+  for (auto idx : vars) {
+    const signed char tmp = val (idx);
+    if (!tmp) continue;
+    if (!var (idx).level) continue;
+    LOG ("initial assignment %ds", tmp < 0 ? -idx : idx);
+    initial.assigned++;
+  }
+
+  PHASE ("condition", stats.conditionings,
+    "initial assignment of size %zd", initial.assigned);
+
+  // For each candidate clause we refine the assignment (monotonically),
+  // by unassigning some conditional literals and turning some autarky
+  // literals into conditionals.
+  //
+  // As the conditional part is usually smaller than the autarky part our
+  // implementation only explicitly maintains the initial conditional part,
+  // with conditional bit set to true through 'mark_as_conditional_literal'.
+  // The autarky part consists of all literals assigned true which do not
+  // have their conditional bit set to true.  Since in both cases the
+  // literal has to be assigned true, we only need a single bit for both the
+  // literal as well as its negation (it does not have to be 'signed').
+  //
+  vector<int> conditional;
+
+  vector<Clause *> candidates;  // Gather candidate clauses.
+  size_t watched = 0;           // Number of watched clauses.
+
+  initial.autarky = initial.assigned;   // Initially all are in autarky
+  initial.conditional = 0;              // and none in conditional part.
+
+  // Upper bound on the number of watched clauses. In principle one could
+  // use 'SIZE_MAX' but this is not available by default (yet).
+  //
+  const size_t size_max = clauses.size () + 1;
+
+  // Initialize additional occurrence lists.
+  //
+  init_occs ();
+
+  // Number of previously conditioned and unconditioned candidates.
+  //
+  size_t conditioned = 0, unconditioned = 0;
+
+  // Now go over all (non-garbage) irredundant clauses and check whether
+  // they are candidates, have to be watched, or whether they force the
+  // negation of some of their literals to be conditional initially.
+  //
+  for (const auto & c : clauses) {
+    if (c->garbage) continue;   // Can already be ignored.
+    if (c->redundant) continue; // Ignore redundant clauses too.
+
+    // First determine the following numbers for the candidate clause
+    // (restricted to non-root-level assignments).
+    //
+    int positive = 0;           // Number true literals.
+    int negative = 0;           // Number false literals.
+    int watch = 0;              // True Literal to watch.
+    //
+    size_t minsize = size_max;  // Number of occurrences of 'watch'.
+    //
+    // But also ignore root-level satisfied but not yet garbage clauses.
+    //
+    bool satisfied = false;     // Root level satisfied.
+    //
+    for (const_literal_iterator l = c->begin ();
+         !satisfied && l != c->end ();
+         l++)
+    {
+      const int lit = *l;
+      const signed char tmp = val (lit);
+      if (tmp && !var (lit).level) satisfied = (tmp > 0);
+      else if (tmp < 0) negative++;
+      else if (tmp > 0) {
+        const size_t size = occs (lit).size ();
+        if (size < minsize) watch = lit, minsize = size;
+        positive++;
+      }
+    }
+    if (satisfied) {            // Ignore root-level satisfied clauses.
+      mark_garbage (c);         // But mark them as garbage already now.
+      continue;                 // ... with next clause 'c'.
+    }
+
+    // Candidates are clauses with at least a positive literal in it.
+    //
+    if (positive > 0) {
+      LOG (c, "found %d positive literals in candidate", positive);
+      candidates.push_back (c);
+      if (c->conditioned) conditioned++;
+      else unconditioned++;
+    }
+
+    // Only one positive literal in each clauses with also at least one
+    // negative literal has to be watched in occurrence lists.  These
+    // watched clauses will be checked to contain only negative literals as
+    // soon such a positive literal is unassigned.  If this is the case
+    // these false literals have to be unassigned and potentially new
+    // conditional literals have to be determined.
+    //
+    // Note that only conditional literals are unassigned. However it does
+    // not matter that we might also watch autarky literals, because either
+    // such an autarky literal remains a witness that the clause is
+    // satisfied as long it remains an autarky literal. Otherwise at one
+    // point it becomes conditional and is unassigned, but then a
+    // replacement watch will be searched.
+    //
+    if (negative > 0 && positive > 0) {
+      LOG (c, "found %d negative literals in candidate", negative);
+      assert (watch);
+      assert (val (watch) > 0);
+      Occs & os = occs (watch);
+      assert (os.size () == minsize);
+      os.push_back (c);
+      watched++;
+      LOG (c, "watching %d with %zd occurrences in", watch, minsize);
+    }
+
+    // The initial global conditional part for the current assignment is
+    // extracted from clauses with only negative literals.  It is the same
+    // for all considered candidate clauses. These negative literals make up
+    // the global conditional part, are marked here.
+    //
+    if (negative > 0 && !positive) {
+
+      size_t new_conditionals = 0;
+
+      for (const_literal_iterator l = c->begin ();
+           l != c->end ();
+           l++)
+      {
+        const int lit = *l;
+        signed char tmp = val (lit);
+        if (!tmp) continue;
+        assert (tmp < 0);
+        if (!var (lit).level) continue; // Not unassigned yet!
+        if (is_conditional_literal (-lit)) continue;
+        mark_as_conditional_literal (-lit);
+        conditional.push_back (-lit);
+        new_conditionals++;
+      }
+      if (new_conditionals > 0)
+        LOG (c, "marked %zu negations of literals as conditional in",
+          new_conditionals);
+
+      initial.conditional += new_conditionals;
+      assert (initial.autarky >= new_conditionals);
+      initial.autarky -= new_conditionals;
+    }
+
+  } // End of loop over all clauses to collect candidates etc.
+
+  PHASE ("condition", stats.conditionings,
+    "found %zd candidate clauses", candidates.size ());
+  PHASE ("condition", stats.conditionings,
+    "watching %zu literals and clauses", watched);
+  PHASE ("condition", stats.conditionings,
+    "initially %zd conditional literals %.0f%%",
+    initial.conditional, percent (initial.conditional, initial.assigned));
+  PHASE ("condition", stats.conditionings,
+    "initially %zd autarky literals %.0f%%",
+    initial.autarky, percent (initial.autarky, initial.assigned));
+#ifdef LOGGING
+  for (size_t i = 0; i < conditional.size (); i++) {
+    LOG ("initial conditional %d", conditional[i]);
+    assert (is_conditional_literal (conditional[i]));
+  }
+  for (size_t i = 0; i < trail.size (); i++)
+    if (is_autarky_literal (trail[i]))
+      LOG ("initial autarky %d", trail[i]);
+#endif
+  assert (initial.conditional == conditional.size ());
+  assert (initial.assigned == initial.conditional + initial.autarky);
+
+  stats.condassinit += initial.assigned;
+  stats.condcondinit += initial.conditional;
+  stats.condautinit += initial.autarky;
+  stats.condassvars += active ();
+
+  // To speed-up and particularly simplify the code we unassign all
+  // root-level variables temporarily, actually all inactive assigned
+  // variables.  This allows us to avoid tests on whether an assigned
+  // literal is actually root-level assigned and thus should be ignored (not
+  // considered to be assigned).  For this to work we have to ignore root
+  // level satisfied clauses as done above.  These are neither candidates
+  // nor have to be watched.  Remaining originally root-level assigned
+  // literals in clauses are only set to false.
+  //
+  for (const auto & lit : trail)
+    if (fixed (lit))
+      condition_unassign (lit);
+
+  // Stack to save temporarily unassigned (conditional) literals.
+  //
+  vector<int> unassigned;
+
+  // Make sure to focus on clauses not tried before by marking clauses which
+  // have been checked before using the 'conditioned' bit of clauses. If all
+  // candidates have their bit set, we have to reset it.  Since the
+  // assignment might be completely different then last time and thus also
+  // the set of candidates this method does not really exactly lead to a
+  // round robin scheme of scheduling clauses.
+  //
+  // TODO consider computing conditioned and unconditioned over all clauses.
+  //
+  assert (conditioned + unconditioned == candidates.size ());
+  if (conditioned && unconditioned) {
+    stable_sort (candidates.begin (), candidates.end (), less_conditioned ());
+    PHASE ("condition", stats.conditionings,
+      "focusing on %zd candidates %.0f%% not tried last time",
+      unconditioned, percent (unconditioned, candidates.size ()));
+  } else if (conditioned && !unconditioned) {
+    for (auto const & c : candidates) {
+      assert (c->conditioned);
+      c->conditioned = false;           // Reset 'conditioned' bit.
+    }
+    PHASE ("condition", stats.conditionings,
+      "all %zd candidates tried before", conditioned);
+  } else {
+    assert (!conditioned);
+    PHASE ("condition", stats.conditionings,
+      "all %zd candidates are fresh", unconditioned);
+  }
+
+  // TODO prune assignments further!
+  // And thus might result in less watched clauses.
+  // So watching should be done here and not earlier.
+  // Also, see below, we might need to consider the negation of unassigned
+  // literals in candidate clauses as being watched.
+
+  // Now try to block all candidate clauses.
+  //
+  long blocked = 0;             // Number of Successfully blocked clauses.
+  //
+  size_t untried = candidates.size ();
+  for (const auto & c : candidates) {
+
+    if (initial.autarky <= 0) break;
+
+    if (c->reason) continue;
+
+    bool terminated_or_limit_hit = true;
+    if (terminated_asynchronously ())
+      LOG ("asynchronous termination detected");
+    else if (stats.condprops >= limit)
+      LOG ("condition propagation limit %ld hit", limit);
+    else terminated_or_limit_hit = false;
+
+    if (terminated_or_limit_hit) {
+      PHASE ("condition", stats.conditionings,
+        "%zd candidates %.0f%% not tried after %ld propagations",
+        untried, percent (untried, candidates.size ()), props);
+      break;
+    }
+    untried--;
+
+    assert (!c->garbage);
+    assert (!c->redundant);
+
+    LOG (c, "candidate");
+    c->conditioned = 1;                 // Next time later.
+
+    // We watch an autarky literal in the clause, and can stop trying to
+    // globally block the clause as soon it turns into a conditional
+    // literal and we can not find another one.  If the fix-point assignment
+    // is reached and we still have an autarky literal left the watched one
+    // is reported as witness for this clause being globally blocked.
+    //
+    int watched_autarky_literal = 0;
+
+    // First mark all true literals in the candidate clause and find an
+    // autarky literal which witnesses that this clause has still a chance
+    // to be globally blocked.
+    //
+    for (const_literal_iterator l = c->begin (); l != c->end (); l++)
+    {
+      const int lit = *l;
+      mark_in_candidate_clause (lit);
+      if (watched_autarky_literal) continue;
+      if (!is_autarky_literal (lit)) continue;
+      watched_autarky_literal = lit;
+
+      // TODO assign non-assigned literals to false?
+      // Which might need to trigger watching additional clauses.
+    }
+
+    if (!watched_autarky_literal) {
+      LOG ("no initial autarky literal found");
+      for (const_literal_iterator l = c->begin (); l != c->end (); l++)
+        unmark_in_candidate_clause (*l);
+      continue;
+    }
+
+    stats.condcands++;          // Only now ...
+
+    LOG ("watching first autarky literal %d", watched_autarky_literal);
+
+    // Save assignment sizes for statistics, logging and checking.
+    //
+    remain = initial;
+
+    // Position of next conditional and unassigned literal to process in the
+    // 'conditional' and the 'unassigned' stack.
+    //
+    struct { size_t conditional, unassigned; } next = { 0, 0 };
+
+    assert (unassigned.empty ());
+    assert (conditional.size () == initial.conditional);
+
+    while (watched_autarky_literal &&
+           stats.condprops < limit &&
+           next.conditional < conditional.size ()) {
+
+      assert (next.unassigned == unassigned.size ());
+
+      const int conditional_lit = conditional[next.conditional++];
+      LOG ("processing next conditional %d", conditional_lit);
+      assert (is_conditional_literal (conditional_lit));
+
+      if (is_in_candidate_clause (-conditional_lit)) {
+        LOG ("conditional %d negated in candidate clause", conditional_lit);
+        continue;
+      }
+
+      LOG ("conditional %d does not occur negated in candidate clause",
+        conditional_lit);
+
+      condition_unassign (conditional_lit);
+      assert (!is_conditional_literal (conditional_lit));
+      unassigned.push_back (conditional_lit);
+
+      assert (remain.assigned > 0);
+      assert (remain.conditional > 0);
+      remain.conditional--;
+      remain.assigned--;
+
+      while (watched_autarky_literal &&
+             stats.condprops < limit &&
+             next.unassigned < unassigned.size ())
+      {
+        const int unassigned_lit = unassigned[next.unassigned++];
+        LOG ("processing next unassigned %d", unassigned_lit);
+        assert (!val (unassigned_lit));
+
+        props++;
+        stats.condprops++;
+
+        Occs & os = occs (unassigned_lit);
+        if (os.empty ()) continue;
+
+        // Traverse all watched clauses of 'unassigned_lit' and find
+        // replacement watches or if none is found turn the negation of all
+        // false autarky literals in that clause into conditional literals.
+        // If one of those autarky literals is the watched autarky literal
+        // in the candidate clause, that one has to be updated too.
+        //
+        // We expect that this loop is a hot-spot for the procedure and thus
+        // are more careful about accessing end points for iterating.
+        //
+        auto i = os.begin (), j = i;
+        for (;
+             watched_autarky_literal && j != os.end ();
+             j++)
+        {
+          Clause * d = *i++ = *j;
+
+          int replacement = 0;  // New watched literal in 'd'.
+          int negative = 0;     // Negative autarky literals in 'd'.
+
+          for (const_literal_iterator l = d->begin ();
+               l != d->end ();
+               l++)
+          {
+            const int lit = *l;
+            const signed char tmp = val (lit);
+            if (tmp > 0) replacement = lit;
+            if (tmp < 0 && is_autarky_literal (-lit)) negative++;
+          }
+
+          if (replacement) {
+            LOG ("found replacement %d for unassigned %d",
+              replacement, unassigned_lit);
+            LOG (d, "unwatching %d in", unassigned_lit);
+            i--;                                            // Drop watch!
+            LOG (d, "watching %d in", replacement);
+
+            assert (replacement != unassigned_lit);
+            occs (replacement).push_back (d);
+
+            continue;                 // ... with next watched clause 'd'.
+          }
+
+          LOG ("no replacement found for unassigned %d", unassigned_lit);
+
+          // Keep watching 'd' by 'unassigned_lit' if no replacement found.
+
+          if (!negative) {
+            LOG (d, "no negative autarky literals left in");
+            continue; // ... with next watched clause 'd'.
+          }
+
+          LOG (d, "found %d negative autarky literals in", negative);
+
+          for (const_literal_iterator l = d->begin ();
+               watched_autarky_literal && l != d->end ();
+               l++)
+          {
+            const int lit = *l;
+            if (!is_autarky_literal (-lit)) continue;
+            mark_as_conditional_literal (-lit);
+            conditional.push_back (-lit);
+
+            remain.conditional++;
+            assert (remain.autarky > 0);
+            remain.autarky--;
+
+            if (-lit != watched_autarky_literal) continue;
+
+            LOG ("need to replace autarky literal %d in candidate", -lit);
+            replacement = 0;
+
+            // TODO save starting point because we only move it forward?
+
+            for (const_literal_iterator k = c->begin ();
+                 !replacement && k != c->end ();
+                 k++)
+            {
+              const int other = *k;
+              if (is_autarky_literal (other)) replacement = other;
+            }
+            watched_autarky_literal = replacement;
+
+            if (replacement) {
+              LOG (c, "watching autarky %d instead %d in candidate",
+                replacement, watched_autarky_literal);
+              watched_autarky_literal = replacement;
+            } else {
+              LOG ("failed to find an autarky replacement");
+              watched_autarky_literal = 0; // Breaks out of 4 loops!!!!!
+            }
+          } // End of loop of turning autarky literals into conditionals.
+        } // End of loop of all watched clauses of an unassigned literal.
+        //
+        // We might abort the occurrence traversal early but already
+        // removed some watches, thus have to just copy the rest.
+        //
+        if (i < j) {
+          while (j != os.end ()) *i++ = *j++;
+          LOG ("flushed %zd occurrences of %d",
+            os.end () - i, unassigned_lit);
+          os.resize (i - os.begin ());
+        }
+      } // End of loop which goes over all unprocessed unassigned literals.
+    } // End of loop which goes over all unprocessed conditional literals.
+
+    // We are still processing the candidate 'c' and now have reached a
+    // final fix-point assignment partitioned into a conditional and an
+    // autarky part, or during unassigned literals figured that there is no
+    // positive autarky literal left in 'c'.
+
+    LOG ("remaining assignment of size %zd", remain.assigned);
+    LOG ("remaining conditional part of size %zd", remain.conditional);
+    LOG ("remaining autarky part of size %zd", remain.autarky);
+    //
+    assert (remain.assigned - remain.conditional == remain.autarky);
+    //
+#if defined(LOGGING) || !defined(NDEBUG)
+    //
+    // This is a sanity check, that the size of our implicit representation
+    // of the autarky part matches our 'remain' counts.  We need the same
+    // code for determining autarky literals as in the loop below which adds
+    // autarky literals to the extension stack.
+    //
+    struct { size_t assigned, conditional, autarky; } check;
+    check.assigned = check.conditional = check.autarky = 0;
+    for (size_t i = 0; i < trail.size (); i++) {
+      const int lit = trail[i];
+      if (val (lit)) {
+        check.assigned++;
+        if (is_conditional_literal (lit)) {
+          LOG ("remaining conditional %d", lit);
+          assert (!is_autarky_literal (lit));
+          check.conditional++;
+        } else {
+          assert (is_autarky_literal (lit));
+          LOG ("remaining autarky %d", lit);
+          check.autarky++;
+        }
+      } else {
+        assert (!is_autarky_literal (lit));
+        assert (!is_conditional_literal (lit));
+      }
+    }
+    assert (remain.assigned == check.assigned);
+    assert (remain.conditional == check.conditional);
+    assert (remain.autarky == check.autarky);
+#endif
+
+    // Success if an autarky literal is left in the clause and
+    // we did not abort the loop too early because the propagation
+    // limit was hit.
+    //
+    if (watched_autarky_literal && stats.condprops < limit)
+    {
+      assert (is_autarky_literal (watched_autarky_literal));
+      assert (is_in_candidate_clause (watched_autarky_literal));
+
+      blocked++;
+      stats.conditioned++;
+      LOG (c,
+        "positive autarky literal %d globally blocks",
+        watched_autarky_literal);
+
+      LOG ("remaining %zd assigned literals %.0f%%",
+        remain.assigned, percent (remain.assigned, initial.assigned));
+      LOG ("remaining %zd conditional literals %.0f%%",
+        remain.conditional,
+        percent (remain.conditional, remain.assigned));
+      LOG ("remaining %zd autarky literals %.0f%%",
+        remain.autarky, percent (remain.autarky, remain.assigned));
+
+      // A satisfying assignment of a formula after removing a globally
+      // blocked clause might not satisfy that clause.  As for variable
+      // elimination and classical blocked clauses, we thus maintain an
+      // extension stack for reconstructing an assignment which both
+      // satisfies the remaining formula as well as the clause.
+      //
+      // For globally blocked clauses we simply have to flip all literals in
+      // the autarky part and thus save the autarky on the extension stack
+      // in addition to the removed clause.  In the classical situation (in
+      // bounded variable elimination etc.) we simply save one literal on
+      // the extension stack.
+      //
+      // TODO find a way to shrink the autarky part or some other way to
+      // avoid pushing too many literals on the extension stack.
+      //
+      external->push_zero_on_extension_stack ();
+      for (const auto & lit : trail)
+        if (is_autarky_literal (lit))
+          external->push_witness_literal_on_extension_stack (lit);
+      external->push_clause_on_extension_stack (c);
+
+      mark_garbage (c);
+
+      stats.condassrem += remain.assigned;
+      stats.condcondrem += remain.conditional;
+      stats.condautrem += remain.autarky;
+      stats.condassirem += initial.assigned;
+    }
+
+    // In this last part specific to one candidate clause, we have to get
+    // back to the initial assignment and reset conditionals.  First we
+    // assign all the unassigned literals (if necessary).
+    //
+    if (!unassigned.empty ()) {
+      LOG ("reassigning %zd literals", unassigned.size ());
+      while (!unassigned.empty ()) {
+        const int lit = unassigned.back ();
+        unassigned.pop_back ();
+        condition_assign (lit);
+      }
+    }
+
+    // Then we remove from the conditional stack autarky literals which
+    // became conditional and also reset their 'conditional' bit.
+    //
+    if (initial.conditional < conditional.size ()) {
+      LOG ("flushing %zd autarky literals from conditional stack",
+        conditional.size () - initial.conditional);
+      while (initial.conditional < conditional.size ()) {
+        const int lit = conditional.back ();
+        conditional.pop_back ();
+        unmark_as_conditional_literal (lit);
+      }
+    }
+
+    // Finally unmark all literals in the candidate clause.
+    //
+    for (const_literal_iterator l = c->begin (); l != c->end (); l++)
+      unmark_in_candidate_clause (*l);
+
+  } // End of loop over all candidate clauses.
+
+  PHASE ("condition", stats.conditionings,
+    "globally blocked %ld clauses %.0f%%",
+    blocked, percent (blocked, candidates.size ()));
+
+  // Unmark initial conditional variables.
+  //
+  for (const auto & lit : conditional)
+    unmark_as_conditional_literal (lit);
+
+  erase_vector (unassigned);
+  erase_vector (conditional);
+  erase_vector (candidates);
+
+  // Unassign additionally assigned literals.
+  //
+  int additionally_unassigned = 0;
+  while (trail.size () > initial_trail_level) {
+    int lit = trail.back ();
+    trail.pop_back ();
+    condition_unassign (lit);
+    additionally_unassigned++;
+  }
+  LOG ("unassigned %d additionally assigned literals",
+    additionally_unassigned);
+  assert (additionally_unassigned == additionally_assigned);
+
+  if (level > initial_level) {
+    LOG ("reset condition decision level");
+    level = initial_level;
+  }
+
+  reset_occs ();
+
+  // Reassign previously assigned variables again.
+  //
+  LOG ("reassigning previously assigned variables");
+  for (size_t i = 0; i < initial_trail_level; i++) {
+    const int lit = trail[i];
+    const signed char tmp = val (lit);
+    assert (tmp >= 0);
+    if (!tmp) condition_assign (lit);
+  }
+
+#ifndef NDEBUG
+  for (const auto & lit : trail)
+    assert (!marked (lit));
+#endif
+
+  unprotect_reasons ();
+
+  return blocked;
+}
+
+void Internal::condition (bool update_limits) {
+
+  if (unsat) return;
+  if (!stats.current.irredundant) return;
+
+  START_SIMPLIFIER (condition, CONDITION);
+  stats.conditionings++;
+
+  // Propagation limit to avoid too much work in 'condition'.  We mark
+  // tried candidate clauses after giving up, such that next time we run
+  // 'condition' we can try them.
+  //
+  long limit = stats.propagations.search;
+  limit *= opts.conditionreleff;
+  limit /= 1000;
+  if (limit < opts.conditionmineff) limit = opts.conditionmineff;
+  if (limit > opts.conditionmaxeff) limit = opts.conditionmaxeff;
+  assert (stats.current.irredundant);
+  limit *= 2.0 * active () / (double) stats.current.irredundant;
+  limit = max (limit, 2l* active ());
+
+  PHASE ("condition", stats.conditionings,
+    "started after %" PRIu64 " conflicts limited by %ld propagations",
+    stats.conflicts, limit);
+
+  long blocked = condition_round (limit);
+
+  STOP_SIMPLIFIER (condition, CONDITION);
+  report ('g', !blocked);
+
+  if (!update_limits) return;
+
+  long delta = opts.conditionint * (stats.conditionings + 1);
+  lim.condition = stats.conflicts + delta;
+
+  PHASE ("condition", stats.conditionings,
+    "next limit at %" PRIu64 " after %ld conflicts",
+    lim.condition, delta);
+}
+
+}
diff --git a/hCaD_V2/src/config.cpp b/hCaD_V2/src/config.cpp
new file mode 100644
index 0000000..1ca5440
--- /dev/null
+++ b/hCaD_V2/src/config.cpp
@@ -0,0 +1,97 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+struct NameVal { const char * name; int val; };
+
+/*------------------------------------------------------------------------*/
+
+// These are dummy configurations, which require additional code.
+
+static NameVal default_config[1];       // With '-pedantic' just '[]' or
+static NameVal plain_config[1];         // '[0]' gave a warning.
+
+/*------------------------------------------------------------------------*/
+
+// Here we have the pre-defined default configurations.
+
+static NameVal sat_config[] = {
+  { "elimreleff", 10 },
+  { "stabilizeonly", 1 },
+  { "subsumereleff", 60 },
+};
+
+static NameVal unsat_config[] = {
+  { "stabilize", 0 },
+  { "walk", 0 },
+};
+
+/*------------------------------------------------------------------------*/
+
+#define CONFIGS \
+ \
+CONFIG(default,"set default advanced internal options") \
+CONFIG(plain,"disable all internal preprocessing options") \
+CONFIG(sat,"set internal options to target satisfiable instances") \
+CONFIG(unsat,"set internal options to target unsatisfiable instances") \
+
+static const char * configs [] = {
+#define CONFIG(N,D) #N,
+CONFIGS
+#undef CONFIG
+};
+
+static size_t num_configs = sizeof configs / sizeof *configs;
+
+/*------------------------------------------------------------------------*/
+
+bool Config::has (const char * name) {
+#define CONFIG(N,D) \
+  if (!strcmp (name, #N)) return true;
+  CONFIGS
+#undef CONFIG
+  return false;
+}
+
+bool Config::set (Options & opts, const char * name) {
+  if (!strcmp (name, "default")) {
+    opts.reset_default_values ();
+    return true;
+  }
+  if (!strcmp (name, "plain")) {
+    opts.disable_preprocessing ();
+    return true;
+  }
+#define CONFIG(N,D) \
+  do { \
+    if (strcmp (name, #N)) break; \
+    const NameVal * BEGIN = N ## _config; \
+    const NameVal * END = BEGIN + sizeof N ##_config / sizeof (NameVal); \
+    for (const NameVal * P = BEGIN; P != END; P++) { \
+      assert (Options::has (P->name)); \
+      opts.set (P->name, P->val); \
+    } \
+    return true; \
+  } while (0);
+  CONFIGS
+#undef CONFIG
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Config::usage () {
+#define CONFIG(N,D) \
+  printf ("  %-14s " D "\n", "--" #N);
+  CONFIGS
+#undef CONFIG
+}
+
+/*------------------------------------------------------------------------*/
+
+const char ** Config::begin () { return configs; }
+const char ** Config::end () { return &configs[num_configs]; }
+
+}
diff --git a/hCaD_V2/src/config.hpp b/hCaD_V2/src/config.hpp
new file mode 100644
index 0000000..c66a10f
--- /dev/null
+++ b/hCaD_V2/src/config.hpp
@@ -0,0 +1,20 @@
+#ifndef _config_hpp_INCLUDED
+#define _config_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+class Options;
+
+struct Config {
+
+  static bool has (const char *);
+  static bool set (Options &, const char *);
+  static void usage ();
+
+  static const char ** begin ();
+  static const char ** end ();
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/configure b/hCaD_V2/src/configure
new file mode 100644
index 0000000..e761d26
--- /dev/null
+++ b/hCaD_V2/src/configure
@@ -0,0 +1,494 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+# Run './configure' to produce a 'makefile' in the 'build' sub-directory or
+# in any immediate sub-directory different from the 'src', 'scripts' and
+# 'test' directories.
+
+#--------------------------------------------------------------------------#
+
+rm -f configure.log
+
+#--------------------------------------------------------------------------#
+
+# Common default options.
+
+all=no
+debug=no
+logging=no
+check=no
+competition=no
+coverage=no
+profile=no
+contracts=yes
+tracing=yes
+unlocked=yes
+pedantic=no
+options=""
+quiet=no
+m32=no
+
+#--------------------------------------------------------------------------#
+
+if [ -f ./scripts/colors.sh ]
+then
+  . ./scripts/colors.sh
+elif [ -f ../scripts/colors.sh ]
+then
+  . ../scripts/colors.sh
+else
+  BAD=""
+  HILITE=""
+  BOLD=""
+  NORMAL=""
+fi
+
+die () {
+  if [ -f configure.log ]
+  then
+    checklog=" (check also 'configure.log')"
+  else
+    checklog=""
+  fi
+  cecho "${BOLD}configure:${NORMAL} ${BAD}error:${NORMAL} $*${checklog}"
+  exit 1
+}
+
+msg () {
+  cecho "${BOLD}configure:${NORMAL} $*"
+}
+
+# if we can find the 'color.sh' script source it and overwrite color codes
+
+for dir in . ..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+# Parse and handle command line options.
+
+usage () {
+cat << EOF
+usage: configure [ <option> ... ]
+
+where '<option>' is one of the following
+
+-h|--help          print this command line summary
+-g|--debug         compile with debugging information
+-c|--check         compile with assertion checking (default for '-g')
+-l|--log[ging]     include logging code (but disabled by default)
+-a|--all           short cut for all above, e.g., '-g -l' (thus also '-c')
+-q|--quiet         exclude message and profiling code (logging too)
+-p|--pedantic      add '--pedantic' and '-Werror' compilation flag
+-s|--symbols       add '-ggdb3' (even for optimized compilation)
+
+--coverage         compile with '-ftest-coverage -fprofile-arcs' for 'gcov'
+--profile          compile with '-pg' to profile with 'gprof'
+
+--no-contracts     compile without API contract checking code
+--no-tracing       compile without API call tracing code
+
+--competition      configure for the competition
+                   ('--quiet', '--no-contracts', '--no-tracing')
+
+-f...              pass '-f<option>[=<val>]' options to the makefile
+-m32               pass '-m32' to the compiler (compile for 32 bit)
+-ggdb3             pass '-ggdb3' to makefile (like '-s')
+-O|-O[123]         pass '-O' or '-O[123]' to the makefile
+-static...         pass '-static...' option to makefile
+
+The environment variable CXX can be used to set a different C++
+compiler than the default 'g++'.  Similarly you can add additional
+compilation options by setting CXXFLAGS.  For example
+
+  CXX=clang++ CXXFLAGS=-fPIC ./configure
+
+will enforce to use 'clang++' as C++ compiler and also produce
+position independent code.  In order to be shell independent we also
+allow to have the following form.  Thus for instance
+
+  ./configure CXX="g++-8" CXXFLAGS="-fPIC -fsanitize=address"
+
+will have the same effect as
+
+  CXX="g++-8" ./configure -fPIC -fsanitize=address
+
+The following configuration options might be usefull during porting the
+code to a new platform and are usually not necessary to change.
+
+--no-unlocked      force compilation without unlocked IO
+EOF
+exit 0
+}
+
+#--------------------------------------------------------------------------#
+
+while [ $# -gt 0 ]
+do
+  case $1 in
+
+    -h|--help) usage;;
+
+    -a|--all) all=yes;;
+
+    -g|--debug) debug=yes;;
+    -c|--check) check=yes;;
+    -l|--log|--logging) logging=yes;;
+
+    -p|--pedantic) pedantic=yes;;
+    -q|--quiet) quiet=yes;;
+
+    --no-contracts | --no-contract) contracts=no;;
+    --no-tracing | --no-trace) tracing=no;;
+
+    --coverage) coverage=yes;;
+    --profile) profile=yes;;
+
+    --competition) competition=yes;;
+
+    --no-unlocked) unlocked=no;;
+
+    -m32) options="$options $1";m32=yes;;
+    -f*|-ggdb3|-O|-O1|-O2|-O3) options="$options $1";;
+    -s|--symbols) options="$options -ggdb3";;
+    -static*) options="$options $1";;
+
+    CXX=*)
+      CXX="`expr \"$1\" : 'CXX=\(.*\)'`"
+      ;;
+
+    CXXFLAGS=*)
+      CXXFLAGS="`expr \"$1\" : 'CXXFLAGS=\(.*\)'`"
+      ;;
+
+    *) die "invalid option '$1' (try '-h')";;
+
+  esac
+  shift
+done
+
+#--------------------------------------------------------------------------#
+
+if [ $quiet = yes ]
+then
+  [ $logging = yes ] && die "can not combine '-q' with '-l'"
+fi
+
+if [ $all = yes ]
+then
+  [ $check = yes ] && die "'-a' subsumes '-c'"
+  [ $debug = yes ] && die "'-a' subsumes '-g'"
+  [ $logging = yes ] && die "'-a' subsumes '-l'"
+  check=yes
+  debug=yes
+  logging=yes
+elif [ $debug = yes ]
+then
+  [ $check = yes ] && die "'-g' subsumes '-c'"
+  check=yes
+fi
+
+#--------------------------------------------------------------------------#
+
+# Generate and enter 'build' directory if not already in sub-directory.
+
+build_in_default_build_sub_directory () {
+  if [ -d build ]
+  then
+    msg "reusing default 'build' directory"
+  else
+    mkdir build 2>/dev/null || \
+    die "failed to generate 'build' directory"
+    msg "making default 'build' directory"
+  fi
+  cd build
+  msg "building in default ${HILITE}'`pwd`'${NORMAL}"
+  build=build
+}
+
+if [ -f configure -a -f makefile.in -a -d src ]
+then
+  root="`pwd`"
+  build_in_default_build_sub_directory
+elif [ -f ../configure -a -f ../makefile.in -a -d ../src ]
+then
+  cwd="`pwd`"
+  build=`basename "$cwd"`
+  root=`dirname "$cwd"`
+  case x"$build" in
+    xsrc|xtest|xscripts)
+      cd ..
+      build_in_default_build_sub_directory
+      ;;
+    *)
+      msg "building in ${HILITE}'$build'${NORMAL} sub-directory"
+      ;;
+  esac
+else
+  die "call 'configure' from root of CaDiCaL source or a sub-directory"
+fi
+
+msg "root directory '$root'"
+
+#--------------------------------------------------------------------------#
+
+src="$root/src"
+
+if [ -d "$src" ]
+then
+  msg "source directory '$src'"
+else
+  die "could not find source director '$src'"
+fi
+
+#--------------------------------------------------------------------------#
+
+# Prepare '@CXX@' and '@CXXFLAGS@' parameters for 'makefile.in'
+
+[ x"$CXX" = x ] && CXX=g++
+[ x"$CXXFLAGS" = x ] || CXXFLAGS="$CXXFLAGS "
+
+case x"$CXX" in
+  x*g++*|x*clang++*) CXXFLAGS="${CXXFLAGS}-Wall -Wextra";;
+  *) CXXFLAGS="${CXXFLAGS}-W";;
+esac
+
+if [ $debug = yes ]
+then
+  CXXFLAGS="$CXXFLAGS -g"
+else
+  case x"$CXX" in
+    x*g++*|x*clang++*) CXXFLAGS="$CXXFLAGS -O3";;
+    *) CXXFLAGS="$CXXFLAGS -O";;
+  esac
+fi
+
+if [ $m32 = yes ]
+then
+  case x"$CXX" in
+    x*g++*)
+      options="$options -mpc64"
+      msg "forcing portable 64-bit FPU mode ('-mpc64') for '$CXX'"
+      ;;
+  esac
+fi
+
+if [ $competition = yes ]
+then
+  quiet=yes
+  contracts=no
+  tracing=no
+fi
+
+[ $check = no ] && CXXFLAGS="$CXXFLAGS -DNDEBUG"
+[ $logging = yes ] && CXXFLAGS="$CXXFLAGS -DLOGGING"
+[ $quiet = yes ] && CXXFLAGS="$CXXFLAGS -DQUIET"
+[ $profile = yes ] && CXXFLAGS="$CXXFLAGS -pg"
+[ $coverage = yes ] && CXXFLAGS="$CXXFLAGS -ftest-coverage -fprofile-arcs"
+if [ $pedantic = yes ]
+then
+  CXXFLAGS="$CXXFLAGS --pedantic -Werror -std=c++11"
+  case x"$CXX" in
+    x*g++*|x*clang++*) CXXFLAGS="${CXXFLAGS} -Wp,-D_GLIBCXX_ASSERTIONS"
+    ;;
+  esac
+fi
+[ $contracts = no ] && CXXFLAGS="$CXXFLAGS -DNCONTRACTS"
+[ $tracing = no ] && CXXFLAGS="$CXXFLAGS -DNTRACING"
+
+CXXFLAGS="$CXXFLAGS$options"
+
+#--------------------------------------------------------------------------#
+
+case x"$CXX" in
+  x*g++* | x*clang++*) WERROR="-Werror -pedantic";;
+  *) WERROR="";;
+esac
+
+# Check that compilation flags work.
+
+feature=./configure-hello-world
+cat <<EOF > $feature.cpp
+#include <iostream>
+int main () { std::cout << "hello world" << std::endl; }
+EOF
+if $CXX $CXXFLAGS $WERROR -o $feature.exe $feature.cpp 2>>configure.log
+then
+  if [ ! "`$feature.exe 2>>configure.log|tr -d '\r'`" = "hello world" ]
+  then
+    die "execution of '$feature.exe' failed"
+  fi
+else
+  die "test compilation '$feature.cpp'"
+fi
+
+#--------------------------------------------------------------------------#
+
+# Since C99/C++11 is becoming the standard newer versions of 'g++' (7.3 for
+# instance) discourage certain GCC extensions, particularly the GCC version
+# of variadic macros, if the same concept exists in the standard.  This
+# forced us to replace all GCC style 'ARGS...' macros with '...' and
+# '__VA_ARGS__'.  Otherwise compiling the library with '--pedantic -Werror'
+# would fail (configuration flag '-p').  However, older versions of 'gcc'
+# (such as 4.8) would disallow these new forms of macros unless we
+# explicitly enforce the new standard with '-std=c++11'.  Here we try to
+# figure out whether we need that flag.  In earlier versions we used
+# '-std=c++0x' but due to issues with older MacOS builds we switched to
+# '-std=c++11' instead.
+
+feature=./configure-requires-c++11
+cat <<EOF > $feature.cpp
+#include <cstdio>
+#include <vector>
+
+// old variadic macro usage 'ARGS...' / '#ARGS' discouraged in g++-7...
+// new variadic macro usage '...' / '__VA_ARGS__' available in C99/C++11
+//
+#define MACRO(FMT, ...) printf (FMT "\n", __VA_ARGS__)
+
+// we use ranged for loops which became available in gcc 4.6 and for
+// the gcc 4.6 as well as 4.8 requires '-std=c++11' too.
+//
+unsigned f (const std::vector<unsigned> & a) {
+  unsigned res = 0;
+  for (auto i : a) res += i;
+  return res;
+}
+
+
+int main () { MACRO ("%d", 42); return 0; }
+EOF
+if $CXX $CXXFLAGS $WERROR -o $feature.exe $feature.cpp 2>>configure.log
+then
+  if [ "`$feature.exe 2>>configure.log|tr -d '\r'`" = 42 ]
+  then
+    msg "compiler supports all required C99/C++11 extensions"
+  else
+    die "checking compilation without '-std=c++11' failed"
+  fi
+else
+  CXXFLAGS="$CXXFLAGS -std=c++11"
+  if $CXX $CXXFLAGS -o $feature.exe $feature.cpp 2>>configure.log
+  then
+    if [ "`$feature.exe 2>>configure.log|tr -d '\r'`" = 42 ]
+    then
+      msg "using '-std=c++11' for all required C99/C++11 extensions"
+    else
+      die "checking compilation with '-std=c++11' failed"
+    fi
+  else
+    die "compiler does not support C99/C++11 even with '-std=c++11'"
+  fi
+fi
+
+#--------------------------------------------------------------------------#
+
+# Unlocked IO is much faster but not necessarily supported.
+
+if [ $unlocked = yes ]
+then
+  feature=./configure-have-unlocked-io
+cat <<EOF > $feature.cpp
+#include <cstdio>
+int main () {
+  const char * path = "$feature.log";
+  FILE * file = fopen (path, "w");
+  if (!file) return 1;
+  if (putc_unlocked (42, file) != 42) return 1;
+  if (fclose (file)) return 1;
+  file = fopen (path, "r");
+  if (!file) return 1;
+  if (getc_unlocked (file) != 42) return 1;
+  if (fclose (file)) return 1;
+  return 0;
+}
+EOF
+  if $CXX $CXXFLAGS -o $feature.exe $feature.cpp 2>>configure.log
+  then
+    if $feature.exe
+    then
+      msg "unlocked IO with '{putc,getc}_unlocked' seems to work"
+    else
+      msg "not using unlocked IO (running '$feature.exe' failed)"
+      unlocked=no
+    fi
+  else
+    msg "not using unlocked IO (failed to compile '$feature.cpp')"
+    unlocked=no
+  fi
+else
+  msg "not using unlocked IO (since '--no-unlocked' specified)"
+fi
+
+[ $unlocked = no ] && CXXFLAGS="$CXXFLAGS -DNUNLOCKED"
+
+#--------------------------------------------------------------------------#
+
+# Instantiate '../makefile.in' template to produce 'makefile' in 'build'.
+
+msg "compiling with ${HILITE}'$CXX $CXXFLAGS'${NORMAL}"
+
+rm -f makefile
+sed \
+-e "2c\\
+# This 'makefile' is generated from '../makefile.in'." \
+-e "s,@CXX@,$CXX," \
+-e "s#@CXXFLAGS@#$CXXFLAGS#" \
+../makefile.in > makefile
+
+msg "generated '$build/makefile' from '../makefile.in'"
+
+#--------------------------------------------------------------------------#
+
+build="`pwd`"
+makefile="`dirname "$build"`/makefile"
+cat <<EOF > "$makefile"
+CADICALBUILD=$build
+all:
+	\$(MAKE) -C "\$(CADICALBUILD)"
+clean:
+	@if [ -d "\$(CADICALBUILD)" ]; \\
+	then \\
+	  if [ -f "\$(CADICALBUILD)"/makefile ]; \\
+	  then \\
+	     touch "\$(CADICALBUILD)"/build.hpp; \\
+	     \$(MAKE) -C "\$(CADICALBUILD)" clean; \\
+	  fi; \\
+	  rm -rf "\$(CADICALBUILD)"; \\
+	fi
+	rm -f "$src/makefile"
+	rm -f "$makefile"
+test:
+	\$(MAKE) -C "\$(CADICALBUILD)" test
+cadical:
+	\$(MAKE) -C "\$(CADICALBUILD)" cadical
+mobical:
+	\$(MAKE) -C "\$(CADICALBUILD)" mobical
+update:
+	\$(MAKE) -C "\$(CADICALBUILD)" update
+.PHONY: all cadical clean mobical test update
+EOF
+
+msg "generated '../makefile' as proxy to ..."
+msg "... '$build/makefile'"
+
+#--------------------------------------------------------------------------#
+
+if [ -f $src/makefile ]
+then
+  msg "removing '$src/makefile'"
+  rm -f $src/makefile
+fi
+
+msg "linking '$root/makefile'"
+ln -s $root/makefile $src/makefile
+
+#--------------------------------------------------------------------------#
+
+msg "now run ${HILITE}'make'${NORMAL} to compile CaDiCaL"
+msg "optionally run 'make test'"
diff --git a/hCaD_V2/src/contract.cpp b/hCaD_V2/src/contract.cpp
new file mode 100644
index 0000000..015abfa
--- /dev/null
+++ b/hCaD_V2/src/contract.cpp
@@ -0,0 +1,27 @@
+#ifndef NCONTRACTS
+
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void fatal_message_start ();
+
+// See comments in 'contract.hpp'. Ugly hack we keep for now.
+
+void require_solver_pointer_to_be_non_zero (const void * ptr,
+                                            const char * function_name,
+                                            const char * file_name)
+{
+  if (ptr) return;
+  fatal_message_start ();
+  fprintf (stderr,
+    "invalid API usage of '%s' in '%s': "
+    "solver 'this' pointer zero (not initialized)\n",
+    function_name, file_name);
+  fflush (stderr);
+  abort ();
+}
+
+}
+
+#endif
diff --git a/hCaD_V2/src/contract.hpp b/hCaD_V2/src/contract.hpp
new file mode 100644
index 0000000..ec5a6ba
--- /dev/null
+++ b/hCaD_V2/src/contract.hpp
@@ -0,0 +1,112 @@
+#ifndef _contract_hpp_INCLUDED
+#define _contract_hpp_INCLUDED
+
+/*------------------------------------------------------------------------*/
+#ifndef NCONTRACTS
+/*------------------------------------------------------------------------*/
+
+// If the user violates API contracts while calling functions declared in
+// 'cadical.hpp' and implemented in 'solver.cpp' then an error is reported.
+// Currently we also force aborting the program.  In the future it might be
+// better to allow the user to provide a call back function, which then can
+// for instance throw a C++ exception or execute a 'longjmp' in 'C' etc.
+
+#define CONTRACT_VIOLATED(...) \
+do { \
+  fatal_message_start (); \
+  fprintf (stderr, \
+    "invalid API usage of '%s' in '%s': ", \
+    __PRETTY_FUNCTION__, __FILE__); \
+  fprintf (stderr, __VA_ARGS__); \
+  fputc ('\n', stderr); \
+  fflush (stderr); \
+  abort (); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+// It would be much easier to just write 'REQUIRE (this, "not initialized")'
+// which however produces warnings due to the '-Wnonnull' check. Note, that
+// 'this' is always assumed to be non zero in modern C++.  Much worse, if we
+// use instead 'this != 0' or something similar like 'this != nullptr' then
+// optimization silently removes this check ('gcc-7.4.0' at least) even
+// though of course a zero pointer might be used as 'this' if the user did
+// not initialize it.  The only solution I found is to disable optimization
+// for this check. It does not seem to be necessary for 'clang++' though
+// ('clang++-6.0.0' at least).  The alternative is to not check that the
+// user forgot to initialize the solver pointer, but as long this works we
+// keep this ugly hack. It also forces the function not to be inlined.
+// The actual code I is in 'contract.cpp'.
+//
+void require_solver_pointer_to_be_non_zero (const void *ptr,
+                                            const char * function_name,
+                                            const char * file_name);
+#define REQUIRE_NON_ZERO_THIS() \
+do { \
+  require_solver_pointer_to_be_non_zero (this, \
+    __PRETTY_FUNCTION__, __FILE__); \
+} while (0)
+
+}
+
+/*------------------------------------------------------------------------*/
+
+// These are common shortcuts for 'Solver' API contracts (requirements).
+
+#define REQUIRE(COND,...) \
+do { \
+  if ((COND)) break; \
+  CONTRACT_VIOLATED (__VA_ARGS__); \
+} while (0)
+
+#define REQUIRE_INITIALIZED() \
+do { \
+  REQUIRE_NON_ZERO_THIS (); \
+  REQUIRE(external, "external solver not initialized"); \
+  REQUIRE(internal, "internal solver not initialized"); \
+} while (0)
+
+#define REQUIRE_VALID_STATE() \
+do { \
+  REQUIRE_INITIALIZED (); \
+  REQUIRE(this->state () & VALID, "solver in invalid state"); \
+} while (0)
+
+#define REQUIRE_READY_STATE() \
+do { \
+  REQUIRE_VALID_STATE (); \
+  REQUIRE (state () != ADDING, \
+    "clause incomplete (terminating zero not added)"); \
+} while (0)
+
+#define REQUIRE_VALID_OR_SOLVING_STATE() \
+do { \
+  REQUIRE_INITIALIZED (); \
+  REQUIRE(this->state () & (VALID | SOLVING), \
+    "solver neither in valid nor solving state"); \
+} while (0)
+
+#define REQUIRE_VALID_LIT(LIT) \
+do { \
+  REQUIRE ((int)(LIT) && ((int) (LIT)) != INT_MIN, \
+    "invalid literal '%d'", (int)(LIT)); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+#else // NCONTRACTS
+/*------------------------------------------------------------------------*/
+
+#define REQUIRE(...) do { } while (0)
+#define REQUIRE_INITIALIZED() do { } while (0)
+#define REQUIRE_VALID_STATE() do { } while (0)
+#define REQUIRE_READY_STATE() do { } while (0)
+#define REQUIRE_VALID_OR_SOLVING_STATE() do { } while (0)
+#define REQUIRE_VALID_LIT(...) do { } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/hCaD_V2/src/cover.cpp b/hCaD_V2/src/cover.cpp
new file mode 100644
index 0000000..292a94c
--- /dev/null
+++ b/hCaD_V2/src/cover.cpp
@@ -0,0 +1,588 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Covered clause elimination (CCE) is described in our short LPAR-10 paper
+// and later in more detail in our JAIR'15 article.  Actually implement
+// the asymmetric version which adds asymmetric literals too but still call
+// it 'CCE' in the following (and not 'ACCE').  This implementation provides
+// a simplified and cleaner version of the one implemented before in
+// Lingeling. We still follow quite closely the original description in the
+// literature, which is based on asymmetric literal addition (ALA) and
+// covered literal addition (CLA).  Both can be seen as kind of propagation,
+// where the literals in the original and then extended clause are assigned
+// to false, and the literals on the trail (actually we use our own 'added'
+// stack for that) make up the extended clause.   The ALA steps can be
+// implemented by simple propagation (copied from 'propagate.cpp') using
+// watches, while the CLA steps need full occurrence lists to determine the
+// resolution candidate clauses.  The CCE is successful if a conflict is
+// found during ALA steps or if during a CLA step all resolution candidates
+// of a literal on the trail are satisfied (the extended clause is blocked).
+
+struct Coveror
+{
+  std::vector<int> added;        // acts as trail
+  std::vector<int> extend;       // extension stack for witness
+  std::vector<int> covered;      // clause literals or added through CLA
+  std::vector<int> intersection; // of literals in resolution candidates
+
+  size_t alas, clas;             // actual number of ALAs and CLAs
+
+  struct { size_t added, covered; } next;       // propagate next ...
+
+  Coveror () : alas (0), clas (0) { }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Push on the extension stack a clause made up of the given literal, the
+// original clause (initially copied to 'covered') and all the added covered
+// literals so far.  The given literal will act as blocking literal for that
+// clause, if CCE is successful.  Only in this case, this private extension
+// stack is copied to the actual extension stack of the solver.  Note, that
+// even though all 'added' clauses correspond to the extended clause, we
+// only need to save the original and added covered literals.
+
+inline void
+Internal::cover_push_extension (int lit, Coveror & coveror) {
+  coveror.extend.push_back (0);
+  coveror.extend.push_back (lit);       // blocking literal comes first
+  bool found = false;
+  for (const auto & other : coveror.covered)
+    if (lit == other) assert (!found), found = true;
+    else coveror.extend.push_back (other);
+  assert (found);
+  (void) found;
+}
+
+// Successful covered literal addition (CLA) step.
+
+inline void
+Internal::covered_literal_addition (int lit, Coveror & coveror)
+{
+  require_mode (COVER);
+  assert (level == 1);
+  cover_push_extension (lit, coveror);
+  for (const auto & other : coveror.intersection) {
+    LOG ("covered literal addition %d", other);
+    assert (!vals[other]), assert (!vals[-other]);
+    vals[other] = -1, vals[-other] = 1;
+    coveror.covered.push_back (other);
+    coveror.added.push_back (other);
+    coveror.clas++;
+  }
+  coveror.next.covered = 0;
+}
+
+// Successful asymmetric literal addition (ALA) step.
+
+inline void
+Internal::asymmetric_literal_addition (int lit, Coveror & coveror)
+{
+  require_mode (COVER);
+  assert (level == 1);
+  LOG ("initial asymmetric literal addition %d", lit);
+  assert (!vals[lit]), assert (!vals[-lit]);
+  vals[lit] = -1, vals[-lit] = 1;
+  coveror.added.push_back (lit);
+  coveror.alas++;
+  coveror.next.covered = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// In essence copied and adapted from 'propagate' in 'propagate.cpp'. Since
+// this function is also a hot-spot here in 'cover' we specialize it in the
+// same spirit as 'probe_propagate' and 'vivify_propagate'.  Please refer to
+// the detailed comments for 'propagate' in 'propagate.cpp' for details.
+
+bool
+Internal::cover_propagate_asymmetric (int lit,
+                                      Clause * ignore,
+                                      Coveror & coveror)
+{
+  require_mode (COVER);
+  stats.propagations.cover++;
+  assert (val (lit) < 0);
+  bool subsumed = false;
+  LOG ("asymmetric literal propagation of %d", lit);
+  Watches & ws = watches (lit);
+  const const_watch_iterator eow = ws.end ();
+  watch_iterator j = ws.begin ();
+  const_watch_iterator i = j;
+  while (!subsumed && i != eow) {
+    const Watch w = *j++ = *i++;
+    if (w.clause == ignore) continue;   // costly but necessary here ...
+    const signed char b = val (w.blit);
+    if (b > 0) continue;
+    if (w.clause->garbage) j--;
+    else if (w.binary ()) {
+      if (b < 0) {
+        LOG (w.clause, "found subsuming");
+        subsumed = true;
+      } else asymmetric_literal_addition (-w.blit, coveror);
+    } else {
+      literal_iterator lits = w.clause->begin ();
+      const int other = lits[0]^lits[1]^lit;
+      lits[0] = other, lits[1] = lit;
+      const signed char u = val (other);
+      if (u > 0) j[-1].blit = other;
+      else {
+        const int size = w.clause->size;
+        const const_literal_iterator end = lits + size;
+        const literal_iterator middle = lits + w.clause->pos;
+        literal_iterator k = middle;
+        signed char v = -1;
+        int r = 0;
+        while (k != end && (v = val (r = *k)) < 0)
+          k++;
+        if (v < 0) {
+          k = lits + 2;
+          assert (w.clause->pos <= size);
+          while (k != middle && (v = val (r = *k)) < 0)
+            k++;
+        }
+        w.clause->pos = k - lits;
+        assert (lits + 2 <= k), assert (k <= w.clause->end ());
+        if (v > 0) j[-1].blit = r;
+        else if (!v) {
+          LOG (w.clause, "unwatch %d in", lit);
+          lits[1] = r;
+          *k = lit;
+          watch_literal (r, lit, w.clause);
+          j--;
+        } else if (!u) {
+          assert (v < 0);
+          asymmetric_literal_addition (-other, coveror);
+        } else {
+          assert (u < 0), assert (v < 0);
+          LOG (w.clause, "found subsuming");
+          subsumed = true;
+          break;
+        }
+      }
+    }
+  }
+  if (j != i) {
+    while (i != eow) *j++ = *i++;
+    ws.resize (j - ws.begin ());
+  }
+  return subsumed;
+}
+
+// Covered literal addition (which needs full occurrence lists).  The
+// function returns 'true' if the extended clause is blocked on 'lit.'
+
+bool
+Internal::cover_propagate_covered (int lit, Coveror & coveror)
+{
+  require_mode (COVER);
+
+  assert (val (lit) < 0);
+  if (frozen (lit)) {
+    LOG ("no covered propagation on frozen literal %d", lit);
+    return false;
+  }
+
+  stats.propagations.cover++;
+
+  LOG ("covered propagation of %d", lit);
+  assert (coveror.intersection.empty ());
+
+  Occs & os = occs (-lit);
+  const auto end = os.end ();
+  bool first = true;
+
+  // Compute the intersection of the literals in all the clauses with
+  // '-lit'.  If all these clauses are double satisfied then we know that
+  // the extended clauses (in 'added') is blocked.  All literals in the
+  // intersection can be added as covered literal. As soon the intersection
+  // becomes empty (during traversal of clauses with '-lit') we abort.
+
+  for (auto i = os.begin (); i != end; i++) {
+
+    Clause * c = *i;
+    if (c->garbage) continue;
+
+    // First check whether clause is 'blocked', i.e., is double satisfied.
+
+    bool blocked = false;
+    for (const auto & other : *c) {
+      if (other == -lit) continue;
+      const signed char tmp = val (other);
+      if (tmp < 0) continue;
+      if (tmp > 0) { blocked = true; break; }
+    }
+    if (blocked) {                      // ... if 'c' is double satisfied.
+      LOG (c, "blocked");
+      continue;                         // with next clause with '-lit'.
+    }
+
+    if (first) {
+
+      // Copy and mark literals of first clause.
+
+      for (const auto & other : *c) {
+        if (other == -lit) continue;
+        const signed char tmp = val (other);
+        if (tmp < 0) continue;
+        assert (!tmp);
+        coveror.intersection.push_back (other);
+        mark (other);
+      }
+
+      first = false;
+
+    } else {
+
+      // Unmark all literals in current clause.
+
+      for (const auto & other : *c) {
+        if (other == -lit) continue;
+        signed char tmp = val (other);
+        if (tmp < 0) continue;
+        assert (!tmp);
+        tmp = marked (other);
+        if (tmp > 0) unmark (other);
+      }
+
+      // Then remove from intersection all marked literals.
+
+      const auto end = coveror.intersection.end ();
+      auto j = coveror.intersection.begin ();
+      for (auto k = j; k != end; k++) {
+        const int other = *j++ = *k;
+        const int tmp = marked (other);
+        assert (tmp >= 0);
+        if (tmp) j--, unmark (other);   // remove marked and unmark it
+        else mark (other);              // keep unmarked and mark it
+      }
+      const size_t new_size = j - coveror.intersection.begin ();
+      coveror.intersection.resize (new_size);
+
+      if (!coveror.intersection.empty ()) continue;
+
+      // No covered literal addition candidates in the intersection left!
+      // Move this clause triggering early abort to the beginning.
+      // This is a common move to front strategy to minimize effort.
+
+      auto begin = os.begin ();
+      while (i != begin) {
+        auto prev = i - 1;
+        *i = *prev;
+        i = prev;
+      }
+      *begin = c;
+
+      break;                    // early abort ...
+    }
+  }
+
+  bool res = false;
+  if (first) {
+    LOG ("all resolution candidates with %d blocked", -lit);
+    assert (coveror.intersection.empty ());
+    cover_push_extension (lit, coveror);
+    res = true;
+  } else if (coveror.intersection.empty ()) {
+    LOG ("empty intersection of resolution candidate literals");
+  } else {
+    LOG (coveror.intersection,
+      "non-empty intersection of resolution candidate literals");
+    covered_literal_addition (lit, coveror);
+    unmark (coveror.intersection);
+    coveror.intersection.clear ();
+    coveror.next.covered = 0;           // Restart covering.
+  }
+
+  unmark (coveror.intersection);
+  coveror.intersection.clear ();
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::cover_clause (Clause * c, Coveror & coveror) {
+
+  require_mode (COVER);
+  assert (!c->garbage);
+
+  LOG (c, "trying covered clauses elimination on");
+  bool satisfied = false;
+  for (const auto & lit : *c)
+    if (val (lit) > 0)
+      satisfied = true;
+
+  if (satisfied) {
+    LOG (c, "clause already satisfied");
+    mark_garbage (c);
+    return false;
+  }
+
+  assert (coveror.added.empty ());
+  assert (coveror.extend.empty ());
+  assert (coveror.covered.empty ());
+
+  assert (!level);
+  level = 1;
+  LOG ("assuming literals of candidate clause");
+  for (const auto & lit : *c) {
+    if (val (lit)) continue;
+    asymmetric_literal_addition (lit, coveror);
+    coveror.covered.push_back (lit);
+  }
+
+  bool tautological = false;
+
+  coveror.next.added = coveror.next.covered = 0;
+
+  while (!tautological) {
+    if (coveror.next.added < coveror.added.size ()) {
+      const int lit = coveror.added[coveror.next.added++];
+      tautological = cover_propagate_asymmetric (lit, c, coveror);
+    } else if (coveror.next.covered < coveror.covered.size ()) {
+      const int lit = coveror.covered[coveror.next.covered++];
+      tautological = cover_propagate_covered (lit, coveror);
+    } else break;
+  }
+
+  if (tautological) {
+    if (coveror.extend.empty ()) {
+      stats.cover.asymmetric++;
+      stats.cover.total++;
+      LOG (c, "asymmetric tautological");
+      mark_garbage (c);
+    } else {
+      stats.cover.blocked++;
+      stats.cover.total++;
+      LOG (c, "covered tautological");
+      mark_garbage (c);
+      // Only copy extension stack if successful.
+      int prev = INT_MIN;
+      for (const auto & other : coveror.extend) {
+        if (!prev) {
+          external->push_zero_on_extension_stack ();
+          external->push_witness_literal_on_extension_stack (other);
+          external->push_zero_on_extension_stack ();
+        }
+        if (other)
+          external->push_clause_literal_on_extension_stack (other);
+        prev = other;
+      }
+    }
+  }
+
+  // Backtrack and 'unassign' all literals.
+
+  assert (level == 1);
+  for (const auto & lit : coveror.added)
+    vals[lit] = vals[-lit] = 0;
+  level = 0;
+
+  coveror.covered.clear ();
+  coveror.extend.clear ();
+  coveror.added.clear ();
+
+  return tautological;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Not yet tried and larger clauses are tried first.
+
+struct clause_covered_or_smaller {
+  bool operator () (const Clause * a, const Clause * b) {
+    if (a->covered && !b->covered) return true;
+    if (!a->covered && b->covered) return false;
+    return a->size < b->size;
+  }
+};
+
+int64_t Internal::cover_round () {
+
+  if (unsat) return 0;
+
+  init_watches ();
+  connect_watches (true);     // irredundant watches only is enough
+
+  int64_t delta = stats.propagations.search;
+  delta *= 1e-3 * opts.coverreleff;
+  if (delta < opts.covermineff) delta = opts.covermineff;
+  if (delta > opts.covermaxeff) delta = opts.covermaxeff;
+  delta = max (delta, ((int64_t) 2) * active ());
+
+  PHASE ("cover", stats.cover.count,
+    "covered clause elimination limit of %" PRId64 " propagations", delta);
+
+  int64_t limit = stats.propagations.cover + delta;
+
+  init_occs ();
+
+  vector<Clause *> schedule;
+  Coveror coveror;
+
+  // First connect all clauses and find all not yet tried clauses.
+  //
+  int64_t untried = 0;
+  //
+  for (auto c : clauses) {
+    assert (!c->frozen);
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+    bool satisfied = false, allfrozen = true;
+    for (const auto & lit : *c)
+      if (val (lit) > 0) { satisfied = true; break; }
+      else if (allfrozen && !frozen (lit)) allfrozen = false;
+    if (satisfied) { mark_garbage (c); continue; }
+    if (allfrozen) { c->frozen = true; continue; }
+    for (const auto & lit : *c)
+      occs (lit).push_back (c);
+    if (c->size < opts.coverminclslim) continue;
+    if (c->size > opts.covermaxclslim) continue;
+    if (c->covered) continue;
+    schedule.push_back (c);
+    untried++;
+  }
+
+  if (schedule.empty ()) {
+
+    PHASE ("cover", stats.cover.count,
+      "no previously untried clause left");
+
+    for (auto c : clauses) {
+      if (c->garbage) continue;
+      if (c->redundant) continue;
+      if (c->frozen) { c->frozen = false; continue; }
+      if (c->size < opts.coverminclslim) continue;
+      if (c->size > opts.covermaxclslim) continue;
+      assert (c->covered);
+      c->covered = false;
+      schedule.push_back (c);
+    }
+  } else {      // Mix of tried and not tried clauses ....
+
+    for (auto c : clauses) {
+      if (c->garbage) continue;
+      if (c->redundant) continue;
+      if (c->frozen) { c->frozen = false; continue; }
+      if (c->size < opts.coverminclslim) continue;
+      if (c->size > opts.covermaxclslim) continue;
+      if (!c->covered) continue;
+      schedule.push_back (c);
+    }
+  }
+
+  stable_sort (schedule.begin (), schedule.end (),
+    clause_covered_or_smaller ());
+
+#ifndef QUIET
+  const size_t scheduled = schedule.size ();
+  PHASE ("cover", stats.cover.count,
+    "scheduled %zd clauses %.0f%% with %" PRId64 " untried %.0f%%",
+    scheduled, percent (scheduled, stats.current.irredundant),
+    untried, percent (untried, scheduled));
+#endif
+
+  // Heuristically it should be beneficial to intersect with smaller clauses
+  // first, since then the chances are higher that the intersection of
+  // resolution candidates becomes emptier earlier.
+
+  for (auto lit : lits) {
+    if (!active (lit)) continue;
+    Occs & os = occs (lit);
+    stable_sort (os.begin (), os.end (), clause_smaller_size ());
+  }
+
+  // This is the main loop of trying to do CCE of candidate clauses.
+  //
+  int64_t covered = 0;
+  //
+  while (!terminated_asynchronously () &&
+         !schedule.empty () &&
+         stats.propagations.cover < limit) {
+    Clause * c = schedule.back ();
+    schedule.pop_back ();
+    c->covered = true;
+    if (cover_clause (c, coveror)) covered++;
+  }
+
+#ifndef QUIET
+  const size_t remain = schedule.size ();
+  const size_t tried = scheduled - remain;
+  PHASE ("cover", stats.cover.count,
+    "eliminated %" PRId64 " covered clauses out of %zd tried %.0f%%",
+    covered, tried, percent (covered, tried));
+  if (remain)
+    PHASE ("cover", stats.cover.count,
+      "remaining %zu clauses %.0f%% untried",
+      remain, percent (remain, scheduled));
+  else
+    PHASE ("cover", stats.cover.count,
+      "all scheduled clauses tried");
+#endif
+  reset_occs ();
+  reset_watches ();
+
+  return covered;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::cover () {
+
+  if (!opts.cover) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
+  if (!stats.current.irredundant) return false;
+
+  // TODO: Our current algorithm for producing the necessary clauses on the
+  // reconstruction stack for extending the witness requires a covered
+  // literal addition step which (empirically) conflicts with flushing
+  // during restoring clauses (see 'regr00{48,51}.trace') even though
+  // flushing during restore is disabled by default (as is covered clause
+  // elimination).  The consequence of combining these two options
+  // ('opts.cover' and 'opts.restoreflush') can thus produce incorrect
+  // witness reconstruction and thus invalid witnesses.  This is quite
+  // infrequent (one out of half billion mobical test cases) but as the two
+  // regression traces show, does happen. Thus we disable the combination.
+  //
+  if (opts.restoreflush) return false;
+
+  START_SIMPLIFIER (cover, COVER);
+
+  stats.cover.count++;
+
+  // During variable elimination unit clauses can be generated which need to
+  // be propagated properly over redundant clauses too.  Since variable
+  // elimination avoids to have occurrence lists and watches at the same
+  // time this propagation is delayed until the end of variable elimination.
+  // Since we want to interleave CCE with it, we have to propagate here.
+  // Otherwise this triggers inconsistencies.
+  //
+  if (propagated < trail.size ()) {
+    init_watches ();
+    connect_watches ();         // need to propagated over all clauses!
+    LOG ("elimination produced %zd units",
+         (size_t)(trail.size () - propagated));
+    if (!propagate ()) {
+      LOG ("propagating units before covered clause elimination "
+        "results in empty clause");
+      learn_empty_clause ();
+      assert (unsat);
+    }
+    reset_watches ();
+  }
+  assert (unsat || propagated == trail.size ());
+
+  int64_t covered = cover_round ();
+
+  STOP_SIMPLIFIER (cover, COVER);
+  report ('c', !opts.reportall && !covered);
+
+  return covered;
+}
+
+}
diff --git a/hCaD_V2/src/cover.hpp b/hCaD_V2/src/cover.hpp
new file mode 100644
index 0000000..0735758
--- /dev/null
+++ b/hCaD_V2/src/cover.hpp
@@ -0,0 +1,33 @@
+#ifndef _cover_hpp_INCLUDED
+#define _cover_hpp_INCLUDED
+
+/*------------------------------------------------------------------------*/
+
+// This header only provides the 'COVER' macro for testing.  It is unrelated
+// to 'cover.cpp' which implements covered clause elimination (CCE), but we
+// wanted to use the name base name in both cases.  More explanation on CCE
+// is provided in 'cover.cpp'.
+
+/*------------------------------------------------------------------------*/
+
+// Coverage goal, used similar to 'assert' (but with flipped condition) and
+// also included even if 'NDEBUG' is defined (in optimizing compilation).
+//
+// This should in essence not be used in production code.
+//
+// There seems to be no problem overloading the name 'COVER' of this macro
+// with the constant 'COVER' of 'Internal::Mode' (surprisingly).
+
+#define COVER(COND) \
+do { \
+  if (!(COND)) break; \
+  fprintf (stderr, \
+    "%scadical%s: %s:%d: %s: Coverage goal %s`%s'%s reached.\n", \
+    terr.bold_code (), terr.normal_code (), \
+    __FUNCTION__, __LINE__, __FILE__, \
+    terr.green_code (), # COND, terr.normal_code ()); \
+  fflush (stderr); \
+  abort (); \
+} while (0)
+
+#endif
diff --git a/hCaD_V2/src/decide.cpp b/hCaD_V2/src/decide.cpp
new file mode 100644
index 0000000..8f5249e
--- /dev/null
+++ b/hCaD_V2/src/decide.cpp
@@ -0,0 +1,123 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// This function determines the next decision variable on the queue, without
+// actually removing it from the decision queue, e.g., calling it multiple
+// times without any assignment will return the same result.  This is of
+// course used below in 'decide' but also in 'reuse_trail' to determine the
+// largest decision level to backtrack to during 'restart' without changing
+// the assigned variables (if 'opts.restartreusetrail' is non-zero).
+
+int Internal::next_decision_variable_on_queue () {
+  int64_t searched = 0;
+  int res = queue.unassigned;
+  while (val (res))
+    res = link (res).prev, searched++;
+  if (searched) {
+    stats.searched += searched;
+    update_queue_unassigned (res);
+  }
+  LOG ("next queue decision variable %d bumped %" PRId64 "", res, bumped (res));
+  return res;
+}
+
+// This function determines the best decision with respect to score.
+//
+int Internal::next_decision_variable_with_best_score () {
+  int res = 0;
+  for (;;) {
+    res = scores.front ();
+    if (!val (res)) break;
+    (void) scores.pop_front ();
+  }
+  LOG ("next decision variable %d with score %g", res, score (res));
+  return res;
+}
+
+int Internal::next_decision_variable () {
+  if (use_scores ()) return next_decision_variable_with_best_score ();
+  else               return next_decision_variable_on_queue ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Implements phase saving as well using a target phase during
+// stabilization unless decision phase is forced to the initial value
+// of a phase is forced through the 'phase' option.
+
+int Internal::decide_phase (int idx, bool target) {
+  const int initial_phase = opts.phase ? 1 : -1;
+  int phase = 0;
+  if (force_saved_phase) phase = phases.saved[idx];
+  if (!phase && opts.forcephase) phase = initial_phase;
+  if (!phase) phase = phases.forced[idx];               // TODO swap?
+  if (!phase && target) phase = phases.target[idx];
+  if (!phase) phase = phases.saved[idx];
+
+  if(opts.psids && phases.act[vlit(idx)] != phases.act[vlit(-idx)]) 
+      phase = phases.act[vlit(idx)] > phases.act[vlit(-idx)] ? 1: -1;
+  // The following should no be necessary and in some version we had even
+  // a hard 'COVER' assertion here to check for this.   Unfortunately it
+  // triggered for some users and we could not get to the root cause of
+  // 'phase' still not being set here.  The logic for phase and target
+  // saving is pretty complex, particularly in combination with local
+  // search, and to avoid running in such an issue in the future again, we
+  // now use this 'defensive' code here, even though such defensive code is
+  // considered bad programming practice.
+  //
+  if (!phase) phase = initial_phase;
+
+  return phase * idx;
+}
+
+// The likely phase of an variable used in 'collect' for optimizing
+// co-location of clauses likely accessed together during search.
+
+int Internal::likely_phase (int idx) { return decide_phase (idx, false); }
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::satisfied () {
+  size_t assigned = trail.size ();
+  if (propagated < assigned) return false;
+  if ((size_t) level < assumptions.size ()) return false;
+  return (assigned == (size_t) max_var);
+}
+
+// Search for the next decision and assign it to the saved phase.  Requires
+// that not all variables are assigned.
+
+int Internal::decide () {
+  assert (!satisfied ());
+  START (decide);
+  int res = 0;
+  if ((size_t) level < assumptions.size ()) {
+    const int lit = assumptions[level];
+    assert (assumed (lit));
+    const signed char tmp = val (lit);
+    if (tmp < 0) {
+      LOG ("assumption %d falsified", lit);
+      failing ();
+      res = 20;
+    } else if (tmp > 0) {
+      LOG ("assumption %d already satisfied", lit);
+      level++;
+      control.push_back (Level (0, trail.size ()));
+      LOG ("added pseudo decision level");
+    } else {
+      LOG ("deciding assumption %d", lit);
+      search_assume_decision (lit);
+    }
+  } else {
+    stats.decisions++;
+    int idx = next_decision_variable ();
+    const bool target = (opts.target > 1 || (stable && opts.target));
+    int decision = decide_phase (idx, target);
+    search_assume_decision (decision);
+  }
+  STOP (decide);
+  return res;
+}
+
+}
diff --git a/hCaD_V2/src/decompose.cpp b/hCaD_V2/src/decompose.cpp
new file mode 100644
index 0000000..e6bcd7f
--- /dev/null
+++ b/hCaD_V2/src/decompose.cpp
@@ -0,0 +1,361 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// This implements Tarjan's algorithm for decomposing the binary implication
+// graph intro strongly connected components (SCCs).  Literals in one SCC
+// are equivalent and we replace them all by the literal with the smallest
+// index in the SCC.  These variables are marked 'substituted' and will be
+// removed from all clauses.  Their value will be fixed during 'extend'.
+
+#define TRAVERSED UINT_MAX              // mark completely traversed
+
+struct DFS {
+  unsigned idx;                         // depth first search index
+  unsigned min;                         // minimum reachable index
+  DFS () : idx (0), min (0) { }
+};
+
+// This performs one round of Tarjan's algorithm, e.g., equivalent literal
+// detection and substitution, on the whole formula.  We might want to
+// repeat it since its application might produce new binary clauses or
+// units.  Such units might even result in an empty clause.
+
+bool Internal::decompose_round () {
+
+  if (!opts.decompose) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
+
+  assert (!level);
+
+  START_SIMPLIFIER (decompose, DECOMP);
+
+  stats.decompositions++;
+
+  const size_t size_dfs = 2*(1 + (size_t) max_var);
+  DFS * dfs = new DFS[size_dfs];
+  int * reprs = new int[size_dfs];
+  clear_n (reprs, size_dfs);
+
+  int non_trivial_sccs = 0, substituted = 0;
+#ifndef QUIET
+  int before = active ();
+#endif
+  unsigned dfs_idx = 0;
+
+  vector<int> work;                     // depth first search working stack
+  vector<int> scc;                      // collects members of one SCC
+
+  // The binary implication graph might have disconnected components and
+  // thus we have in general to start several depth first searches.
+
+  for (auto root_idx : vars) {
+    if (unsat) break;
+    if (!active (root_idx)) continue;
+    for (int root_sign = -1; !unsat && root_sign <= 1; root_sign += 2) {
+      int root = root_sign * root_idx;
+      if (dfs[vlit (root)].min == TRAVERSED) continue;  // skip traversed
+      LOG ("new dfs search starting at root %d", root);
+      assert (work.empty ());
+      assert (scc.empty ());
+      work.push_back (root);
+      while (!unsat && !work.empty ()) {
+        int parent = work.back ();
+        DFS & parent_dfs = dfs[vlit (parent)];
+        if (parent_dfs.min == TRAVERSED) {              // skip traversed
+          assert (reprs [vlit (parent)]);
+          work.pop_back ();
+        } else {
+          assert (!reprs [vlit (parent)]);
+
+          // Go over all implied literals, thus need to iterate over all
+          // binary watched clauses with the negation of 'parent'.
+
+          Watches & ws = watches (-parent);
+
+          // Two cases: Either the node has never been visited before, i.e.,
+          // it's depth first search index is zero, then perform the
+          // 'pre-fix' work before visiting it's children.  Otherwise all
+          // it's children and nodes reachable from those children have been
+          // visited and their minimum reachable depth first search index
+          // has been computed.  This second case is the 'post-fix' work.
+
+          if (parent_dfs.idx) {                         // post-fix
+
+            work.pop_back ();                           // 'parent' done
+
+            // Get the minimum reachable depth first search index reachable
+            // from the children of 'parent'.
+
+            unsigned new_min = parent_dfs.min;
+
+            for (const auto & w : ws) {
+              if (!w.binary ()) continue;
+              const int child = w.blit;
+              if (!active (child)) continue;
+              const DFS & child_dfs = dfs[vlit (child)];
+              if (new_min > child_dfs.min) new_min = child_dfs.min;
+            }
+
+            LOG ("post-fix work dfs search %d index %u reaches minimum %u",
+              parent, parent_dfs.idx, new_min);
+
+            if (parent_dfs.idx == new_min) {            // entry to SCC
+
+              // All nodes on the 'scc' stack after and including 'parent'
+              // are in the same SCC.  Their representative is computed as
+              // the smallest literal (index-wise) in the SCC.  If the SCC
+              // contains both a literal and its negation, then the formula
+              // becomes unsatisfiable.
+
+              int other, size = 0, repr = parent;
+              assert (!scc.empty ());
+              size_t j = scc.size ();
+              do {
+                assert (j > 0);
+                other = scc[--j];
+                if (other == -parent) {
+                  LOG ("both %d and %d in one SCC", parent, -parent);
+                  assign_unit (parent);
+                  learn_empty_clause ();
+                } else {
+                  if (abs (other) < abs (repr)) repr = other;
+                  size++;
+                }
+              } while (!unsat && other != parent);
+
+              if (!unsat) {
+
+                LOG ("SCC of representative %d of size %d", repr, size);
+
+                do {
+                  assert (!scc.empty ());
+                  other = scc.back ();
+                  scc.pop_back ();
+                  dfs[vlit (other)].min = TRAVERSED;
+                  if (frozen (other)) {
+                    reprs[vlit (other) ] = other;
+                  } else {
+                    reprs[vlit (other)] = repr;
+                    if (other != repr) {
+                      substituted++;
+                      LOG ("literal %d in SCC of %d", other, repr);
+                    }
+                  }
+                } while (other != parent);
+
+                if (size > 1) non_trivial_sccs++;
+              }
+
+            } else {
+
+              // Current node 'parent' is in a non-trivial SCC but is not
+              // the entry point of the SCC in this depth first search, so
+              // keep it on the SCC stack until the entry point is reached.
+
+              parent_dfs.min = new_min;
+            }
+
+          } else {                                      // pre-fix
+
+            dfs_idx++;
+            assert (dfs_idx < TRAVERSED);
+            parent_dfs.idx = parent_dfs.min = dfs_idx;
+            scc.push_back (parent);
+
+            LOG ("pre-fix work dfs search %d index %u", parent, dfs_idx);
+
+            // Now traverse all the children in the binary implication
+            // graph but keep 'parent' on the stack for 'post-fix' work.
+
+            for (const auto & w : ws) {
+              if (!w.binary ()) continue;
+              const int child = w.blit;
+              if (!active (child)) continue;
+              const DFS & child_dfs = dfs[vlit (child)];
+              if (child_dfs.idx) continue;
+              work.push_back (child);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  erase_vector (work);
+  erase_vector (scc);
+  delete [] dfs;
+
+  // Only keep the representatives 'repr' mapping.
+
+  PHASE ("decompose",
+    stats.decompositions,
+    "%d non-trivial sccs, %d substituted %.2f%%",
+    non_trivial_sccs, substituted, percent (substituted, before));
+
+  bool new_unit = false, new_binary_clause = false;
+
+  vector<Clause*> postponed_garbage;
+
+  // Now go over all clauses and find clause which contain literals that
+  // should be substituted by their representative.
+
+  size_t clauses_size = clauses.size (), garbage = 0, replaced = 0;
+  for (size_t i = 0; substituted && !unsat && i < clauses_size; i++) {
+    Clause * c = clauses[i];
+    if (c->garbage) continue;
+    int j, size = c->size;
+    for (j = 0; j < size; j++) {
+      const int lit = c->literals[j];
+      if (reprs [ vlit (lit) ] != lit) break;
+    }
+
+    if (j == size) continue;
+
+    replaced++;
+    LOG (c, "first substituted literal %d in", substituted);
+
+    // Now copy the result to 'clause'.  Substitute literals if they have a
+    // different representative.  Skip duplicates and false literals.  If a
+    // literal occurs in both phases or is assigned to true the clause is
+    // satisfied and can be marked as garbage.
+
+    assert (clause.empty ());
+    bool satisfied = false;
+
+    for (int k = 0; !satisfied && k < size; k++) {
+      const int lit = c->literals[k];
+      signed char tmp = val (lit);
+      if (tmp > 0) satisfied = true;
+      else if (tmp < 0) continue;
+      else {
+        const int other = reprs [vlit (lit)];
+        tmp = val (other);
+        if (tmp < 0) continue;
+        else if (tmp > 0) satisfied = true;
+        else {
+          tmp = marked (other);
+          if (tmp < 0) satisfied = true;
+          else if (!tmp) {
+            mark (other);
+            clause.push_back (other);
+          }
+        }
+      }
+    }
+
+    if (satisfied) {
+      LOG (c, "satisfied after substitution (postponed)");
+      postponed_garbage.push_back (c);
+      garbage++;
+    } else if (!clause.size ()) {
+      LOG ("learned empty clause during decompose");
+      learn_empty_clause ();
+    } else if (clause.size () == 1) {
+      LOG (c, "unit %d after substitution", clause[0]);
+      assign_unit (clause[0]);
+      mark_garbage (c);
+      new_unit = true;
+      garbage++;
+    } else if (c->literals[0] != clause[0] ||
+               c->literals[1] != clause[1]) {
+      LOG ("need new clause since at least one watched literal changed");
+      if (clause.size () == 2) new_binary_clause = true;
+      size_t d_clause_idx = clauses.size ();
+      Clause * d = new_clause_as (c);
+      assert (clauses[d_clause_idx] == d);
+      clauses[d_clause_idx] = c;
+      clauses[i] = d;
+      mark_garbage (c);
+      garbage++;
+    } else {
+      LOG ("simply shrinking clause since watches did not change");
+      assert (c->size > 2);
+      if (!c->redundant) mark_removed (c);
+      if (proof) {
+        proof->add_derived_clause (clause);
+        proof->delete_clause (c);
+      }
+      size_t l;
+      for (l = 2; l < clause.size (); l++)
+        c->literals[l] = clause[l];
+      int flushed = c->size - (int) l;
+      if (flushed) {
+        if (l == 2) new_binary_clause = true;
+        LOG ("flushed %d literals", flushed);
+        (void) shrink_clause (c, l);
+      } else if (likely_to_be_kept_clause (c)) mark_added (c);
+      LOG (c, "substituted");
+    }
+    while (!clause.empty ()) {
+      int lit = clause.back ();
+      clause.pop_back ();
+      assert (marked (lit) > 0);
+      unmark (lit);
+    }
+  }
+
+  if (!unsat && !postponed_garbage.empty ()) {
+    LOG ("now marking %zd postponed garbage clauses",
+      postponed_garbage.size ());
+    for (const auto & c : postponed_garbage)
+      mark_garbage (c);
+  }
+  erase_vector (postponed_garbage);
+
+  PHASE ("decompose",
+    stats.decompositions,
+    "%zd clauses replaced %.2f%% producing %zd garbage clauses %.2f%%",
+    replaced, percent (replaced, clauses_size),
+    garbage, percent (garbage, replaced));
+
+  erase_vector (scc);
+
+  // Propagate found units.
+
+  if (!unsat && propagated < trail.size () && !propagate ()) {
+    LOG ("empty clause after propagating units from substitution");
+    learn_empty_clause ();
+  }
+
+  // Finally, mark substituted literals as such and push the equivalences of
+  // the substituted literals to their representative on the extension
+  // stack to fix an assignment during 'extend'.
+  //
+  // TODO instead of adding the clauses to the extension stack one could
+  // also just simply use the 'e2i' map as a union find data structure.
+  // This would avoid the need to restore these clauses.
+
+  for (auto idx : vars) {
+    if (unsat) break;
+    if (!active (idx)) continue;
+    int other = reprs [ vlit (idx) ];
+    if (other == idx) continue;
+    assert (!flags (other).eliminated ());
+    assert (!flags (other).substituted ());
+    if (!flags (other).fixed ()) mark_substituted (idx);
+    external->push_binary_clause_on_extension_stack (-idx, other);
+    external->push_binary_clause_on_extension_stack (idx, -other);
+  }
+
+  delete [] reprs;
+
+  flush_all_occs_and_watches ();  // particularly the 'blit's
+
+  bool success = unsat ||
+    (substituted > 0 && (new_unit || new_binary_clause));
+  report ('d', !opts.reportall && !success);
+
+  STOP_SIMPLIFIER (decompose, DECOMP);
+
+  return success;
+}
+
+void Internal::decompose () {
+  for (int round = 1; round <= opts.decomposerounds; round++)
+    if (!decompose_round ())
+      break;
+}
+
+}
diff --git a/hCaD_V2/src/deduplicate.cpp b/hCaD_V2/src/deduplicate.cpp
new file mode 100644
index 0000000..f7e018d
--- /dev/null
+++ b/hCaD_V2/src/deduplicate.cpp
@@ -0,0 +1,139 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Equivalent literal substitution in 'decompose' and shrinking in 'subsume'
+// or 'vivify' might produce duplicated binary clauses.  They can not be
+// found in 'subsume' nor 'vivify' since we explicitly do not consider
+// binary clauses as candidates to be shrunken or subsumed.  They are
+// detected here by a simple scan of watch lists and then marked as garbage.
+// This is actually also quite fast.
+
+// Further it might also be possible that two binary clauses can be resolved
+// to produce a unit (we call it 'hyper unary resolution').  For example
+// resolving the binary clauses '1 -2' and '1 2' produces the unit '1'.
+// This could be found by probing in 'probe' unless '-1' also occurs in a
+// binary clause (add the clause '-1 2' to those two clauses) in which case
+// '1' as well as '2' both occur positively as well as negatively and none
+// of them nor their negation is considered as probe
+
+void Internal::mark_duplicated_binary_clauses_as_garbage () {
+
+  if (!opts.deduplicate) return;
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
+
+  START_SIMPLIFIER (deduplicate, DEDUP);
+  stats.deduplications++;
+
+  assert (!level);
+  assert (watching ());
+
+  vector<int> stack;    // To save marked literals and unmark them later.
+
+  int64_t subsumed = 0;
+  int64_t units = 0;
+
+  for (auto idx : vars) {
+
+    if (unsat) break;
+    if (!active (idx)) continue;
+    int unit = 0;
+
+    for (int sign = -1; !unit && sign <= 1; sign += 2) {
+
+      const int lit = sign * idx;       // Consider all literals.
+
+      assert (stack.empty ());
+      Watches & ws = watches (lit);
+
+      // We are removing references to garbage clause. Thus no 'auto'.
+
+      const const_watch_iterator end = ws.end ();
+      watch_iterator j = ws.begin ();
+      const_watch_iterator i;
+
+      for (i = j; !unit && i != end; i++) {
+        Watch w = *j++ = *i;
+        if (!w.binary ()) continue;
+        int other = w.blit;
+        const int tmp = marked (other);
+        Clause * c = w.clause;
+
+        if (tmp > 0) {                  // Found duplicated binary clause.
+
+          if (c->garbage) { j--; continue; }
+          LOG (c, "found duplicated");
+
+          // The previous identical clause 'd' might be redundant and if the
+          // second clause 'c' is not (so irredundant), then we have to keep
+          // 'c' instead of 'd', thus we search for it and replace it.
+
+          if (!c->redundant) {
+            watch_iterator k;
+            for (k = ws.begin ();;k++) {
+              assert (k != i);
+              if (!k->binary ()) continue;
+              if (k->blit != other) continue;
+              Clause * d = k->clause;
+              if (d->garbage) continue;
+              c = d;
+              break;
+            }
+            *k = w;
+          }
+
+          LOG (c, "mark garbage duplicated");
+          stats.subsumed++;
+          stats.deduplicated++;
+          subsumed++;
+          mark_garbage (c);
+          j--;
+
+        } else if (tmp < 0) {           // Hyper unary resolution.
+
+          LOG ("found %d %d and %d %d which produces unit %d",
+            lit, -other, lit, other, lit);
+          unit = lit;
+          j = ws.begin ();              // Flush 'ws'.
+          units++;
+
+        } else {
+          if (c->garbage) continue;
+          mark (other);
+          stack.push_back (other);
+        }
+      }
+
+      if (j == ws.begin ()) erase_vector (ws);
+      else if (j != end)
+        ws.resize (j - ws.begin ());    // Shrink watchers.
+
+      for (const auto & other : stack)
+        unmark (other);
+
+      stack.clear ();
+    }
+
+    // Propagation potentially messes up the watches and thus we can not
+    // propagate the unit immediately after finding it.  Instead we break
+    // out of both loops and assign and propagate the unit here.
+
+    if (unit) {
+
+      stats.failed++;
+      stats.hyperunary++;
+      assign_unit (unit);
+
+      if (!propagate ()) {
+        LOG ("empty clause after propagating unit");
+        learn_empty_clause ();
+      }
+    }
+  }
+  STOP_SIMPLIFIER (deduplicate, DEDUP);
+
+  report ('2', !opts.reportall && !(subsumed + units));
+}
+
+}
diff --git a/hCaD_V2/src/elim.cpp b/hCaD_V2/src/elim.cpp
new file mode 100644
index 0000000..dbb358b
--- /dev/null
+++ b/hCaD_V2/src/elim.cpp
@@ -0,0 +1,960 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Implements a variant of bounded variable elimination as originally
+// described in our SAT'05 paper introducing 'SATeLite'.  This is an
+// inprocessing version, i.e., it is interleaved with search and triggers
+// subsumption and strengthening, blocked and covered clause elimination
+// during elimination rounds.  It focuses only those variables which
+// occurred in removed irredundant clauses since the last time an
+// elimination round was run.  By bounding the maximum resolvent size we can
+// run each elimination round until completion.  See the code of 'elim' for
+// how elimination rounds are interleaved with blocked clause elimination
+// and subsumption (which in turn also calls vivification and transitive
+// reduction of the binary implication graph).
+
+/*------------------------------------------------------------------------*/
+
+inline double Internal::compute_elim_score (unsigned lit) {
+  assert (1 <= lit), assert (lit <= (unsigned) max_var);
+  const unsigned uidx = 2*lit;
+  const double pos = internal->ntab [uidx];
+  const double neg = internal->ntab [uidx + 1];
+  if (!pos) return -neg;
+  if (!neg) return -pos;
+  double sum = 0, prod = 0;
+  if (opts.elimsum) sum = opts.elimsum * (pos + neg);
+  if (opts.elimprod) prod = opts.elimprod * (pos * neg);
+  return prod + sum;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline bool elim_more::operator () (unsigned a, unsigned b) {
+  const auto s = internal->compute_elim_score (a);
+  const auto t = internal->compute_elim_score (b);
+  if (s > t) return true;
+  if (s < t) return false;
+  return a > b;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Note that the new fast subsumption algorithm implemented in 'subsume'
+// does not distinguish between irredundant and redundant clauses and is
+// also run during search to strengthen and remove 'sticky' redundant
+// clauses but also irredundant ones.  So beside learned units during search
+// or as consequence of other preprocessors, these subsumption rounds during
+// search can remove (irredundant) clauses (and literals), which in turn
+// might make new bounded variable elimination possible.  This is tested
+// in the 'bool eliminating ()' guard.
+
+bool Internal::eliminating () {
+
+  if (!opts.elim) return false;
+  if (!preprocessing && !opts.inprocessing) return false;
+  if (preprocessing) assert (lim.preprocessing);
+
+  // Respect (increasing) conflict limit.
+  //
+  if (lim.elim >= stats.conflicts) return false;
+
+  // Wait until there are new units or new removed variables
+  // (in removed or shrunken irredundant clauses and thus marked).
+  //
+  if (last.elim.fixed < stats.all.fixed) return true;
+  if (last.elim.marked < stats.mark.elim) return true;
+
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Update the global elimination schedule after adding or removing a clause.
+
+void
+Internal::elim_update_added_clause (Eliminator & eliminator, Clause * c) {
+  assert (!c->redundant);
+  ElimSchedule & schedule = eliminator.schedule;
+  for (const auto & lit : *c) {
+    if (!active (lit)) continue;
+    occs (lit).push_back (c);
+    if (frozen (lit)) continue;
+    noccs (lit)++;
+    const int idx = abs (lit);
+    if (schedule.contains (idx)) schedule.update (idx);
+  }
+}
+
+void Internal::elim_update_removed_lit (Eliminator & eliminator, int lit) {
+  if (!active (lit)) return;
+  if (frozen (lit)) return;
+  int64_t & score = noccs (lit);
+  assert (score > 0);
+  score--;
+  const int idx = abs (lit);
+  ElimSchedule & schedule = eliminator.schedule;
+  if (schedule.contains (idx)) schedule.update (idx);
+  else {
+    LOG ("rescheduling %d for elimination after removing clause", idx);
+    schedule.push_back (idx);
+  }
+}
+
+void
+Internal::elim_update_removed_clause (Eliminator & eliminator,
+                                      Clause * c, int except)
+{
+  assert (!c->redundant);
+  for (const auto & lit : *c) {
+    if (lit == except) continue;
+    assert (lit != -except);
+    elim_update_removed_lit (eliminator, lit);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Since we do not have watches we have to do our own unit propagation
+// during elimination as soon we find a unit clause.  This finds new units
+// and also marks clauses satisfied by those units as garbage immediately.
+
+void Internal::elim_propagate (Eliminator & eliminator, int root) {
+  assert (val (root) > 0);
+  vector<int> work;
+  size_t i = 0;
+  work.push_back (root);
+  while (i < work.size ()) {
+    int lit = work[i++];
+    LOG ("elimination propagation of %d", lit);
+    assert (val (lit) > 0);
+    const Occs & ns = occs (-lit);
+    for (const auto & c : ns) {
+      if (c->garbage) continue;
+      int unit = 0, satisfied = 0;
+      for (const auto & other : *c) {
+        const signed char tmp = val (other);
+        if (tmp < 0) continue;
+        if (tmp > 0) { satisfied = other; break; }
+        if (unit) unit = INT_MIN;
+        else unit = other;
+      }
+      if (satisfied) {
+        LOG (c, "elimination propagation of %d finds %d satisfied",
+          lit, satisfied);
+        elim_update_removed_clause (eliminator, c, satisfied);
+        mark_garbage (c);
+      } else if (!unit) {
+        LOG ("empty clause during elimination propagation of %d", lit);
+        learn_empty_clause ();
+        break;
+      } else if (unit != INT_MIN) {
+        LOG ("new unit %d during elimination propagation of %d", unit, lit);
+        assign_unit (unit);
+        work.push_back (unit);
+      }
+    }
+    if (unsat) break;
+    const Occs & ps = occs (lit);
+    for (const auto & c : ps) {
+      if (c->garbage) continue;
+      LOG (c, "elimination propagation of %d produces satisfied", lit);
+      elim_update_removed_clause (eliminator, c, lit);
+      mark_garbage (c);
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// On-the-fly self-subsuming resolution during variable elimination is due
+// to HyoJung Han, Fabio Somenzi, SAT'09.  Basically while resolving two
+// clauses we test the resolvent to be smaller than one of the antecedents.
+// If this is the case the pivot can be removed from the antecedent
+// on-the-fly and the resolution can be skipped during elimination.
+
+void Internal::elim_on_the_fly_self_subsumption (Eliminator & eliminator,
+                                                 Clause * c, int pivot)
+{
+  LOG (c, "pivot %d on-the-fly self-subsuming resolution", pivot);
+  stats.elimotfstr++;
+  stats.strengthened++;
+  assert (clause.empty ());
+  for (const auto & lit : *c) {
+    if (lit == pivot) continue;
+    const signed char tmp = val (lit);
+    assert (tmp <= 0);
+    if (tmp < 0) continue;
+    clause.push_back (lit);
+  }
+  Clause * r = new_resolved_irredundant_clause ();
+  elim_update_added_clause (eliminator, r);
+  clause.clear ();
+  elim_update_removed_clause (eliminator, c, pivot);
+  mark_garbage (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Resolve two clauses on the pivot literal 'pivot', which is assumed to
+// occur in opposite phases in 'c' and 'd'.  The actual resolvent is stored
+// in the temporary global 'clause' if it is not redundant.  It is
+// considered redundant if one of the clauses is already marked as garbage
+// it is root level satisfied, the resolvent is empty, a unit, or produces a
+// self-subsuming resolution, which results in the pivot to be removed from
+// at least one of the antecedents.
+
+// Note that current root level assignments are taken into account, i.e., by
+// removing root level falsified literals.  The function returns true if the
+// resolvent is not redundant and for instance has to be taken into account
+// during bounded variable elimination.
+
+// Detected units are immediately assigned and in case the last argument is
+// true also propagated eagerly in a elimination specific propagation
+// routine, which not only finds units but also updates the schedule.
+
+// When this function is called during computation of the number of
+// non-trivial (or non-satisfied) resolvents we can eagerly propagate units.
+// But during actually adding the resolvents this results in problems as we
+// found one rare test case '../test/trace/reg0056.trace' (out of billions),
+// where the pivot itself was assigned during such a propagation while
+// adding resolvents and lead to pushing a clause to the reconstruction
+// stack that later flipped the value of the pivot (while all other literals
+// in that clause were unit implied too).  Not pushing the pivot clauses to
+// the reconstruction stack produced a wrong model too.  Our fix is to only
+// eagerly propagate during computation of the number of resolvents and
+// otherwise delay propagation until the end of elimination (which is less
+// precise regarding scheduling but very rarely happens).
+
+bool Internal::resolve_clauses (Eliminator & eliminator,
+                                Clause * c, int pivot, Clause * d,
+				const bool propagate_eagerly) {
+
+  assert (!c->redundant);
+  assert (!d->redundant);
+
+  stats.elimres++;
+
+  if (c->garbage || d->garbage) return false;
+  if (c->size > d->size) { pivot = -pivot; swap (c, d); }
+
+  assert (!level);
+  assert (clause.empty ());
+
+  int satisfied = 0;       // Contains this satisfying literal.
+  int tautological = 0;    // Clashing literal if tautological.
+
+  int s = 0;               // Actual literals from 'c'.
+  int t = 0;               // Actual literals from 'd'.
+
+  // First determine whether the first antecedent is satisfied, add its
+  // literals to 'clause' and mark them (except for 'pivot').
+  //
+  for (const auto & lit : *c) {
+    if (lit == pivot) { s++; continue; }
+    assert (lit != -pivot);
+    const signed char tmp = val (lit);
+    if (tmp > 0) { satisfied = lit; break; }
+    else if (tmp < 0) continue;
+    else mark (lit), clause.push_back (lit), s++;
+  }
+  if (satisfied) {
+    LOG (c, "satisfied by %d antecedent", satisfied);
+    elim_update_removed_clause (eliminator, c, satisfied);
+    mark_garbage (c);
+    clause.clear ();
+    unmark (c);
+    return false;
+  }
+
+  // Then determine whether the second antecedent is satisfied, add its
+  // literal to 'clause' and check whether a clashing literal is found, such
+  // that the resolvent would be tautological.
+  //
+  for (const auto & lit : *d) {
+    if (lit == -pivot) { t++; continue; }
+    assert (lit != pivot);
+    signed char tmp = val (lit);
+    if (tmp > 0) { satisfied = lit; break; }
+    else if (tmp < 0) continue;
+    else if ((tmp = marked (lit)) < 0) { tautological = lit; break; }
+    else if (!tmp) clause.push_back (lit), t++;
+    else assert (tmp > 0), t++;
+  }
+
+  unmark (c);
+  const int64_t size = clause.size ();
+
+  if (satisfied) {
+    LOG (d, "satisfied by %d antecedent", satisfied);
+    elim_update_removed_clause (eliminator, d, satisfied);
+    mark_garbage (d);
+    clause.clear ();
+    return false;
+  }
+
+  LOG (c, "first antecedent");
+  LOG (d, "second antecedent");
+
+  if (tautological) {
+    clause.clear ();
+    LOG ("resolvent tautological on %d", tautological);
+    return false;
+  }
+
+  if (!size) {
+    clause.clear ();
+    LOG ("empty resolvent");
+    learn_empty_clause ();
+    return false;
+  }
+
+  if (size == 1) {
+    int unit = clause[0];
+    LOG ("unit resolvent %d", unit);
+    clause.clear ();
+    assign_unit (unit);
+    if (propagate_eagerly)
+      elim_propagate (eliminator, unit);
+    return false;
+  }
+
+  LOG (clause, "resolvent");
+
+  // Double self-subsuming resolution.  The clauses 'c' and 'd' are
+  // identical except for the pivot which occurs in different phase.  The
+  // resolvent subsumes both antecedents.
+
+  if (s > size && t > size) {
+    assert (s == size + 1);
+    assert (t == size + 1);
+    clause.clear ();
+    elim_on_the_fly_self_subsumption (eliminator, c, pivot);
+    LOG (d, "double pivot %d on-the-fly self-subsuming resolution", -pivot);
+    stats.elimotfsub++;
+    stats.subsumed++;
+    elim_update_removed_clause (eliminator, d, -pivot);
+    mark_garbage (d);
+    return false;
+  }
+
+  // Single self-subsuming resolution:  The pivot can be removed from 'c',
+  // which is implemented by adding a clause which is the same as 'c' but
+  // with 'pivot' removed and then marking 'c' as garbage.
+
+  if (s > size) {
+    assert (s == size + 1);
+    clause.clear ();
+    elim_on_the_fly_self_subsumption (eliminator, c, pivot);
+    return false;
+  }
+
+  // Same single self-subsuming resolution situation, but only for 'd'.
+
+  if (t > size) {
+    assert (t == size + 1);
+    clause.clear ();
+    elim_on_the_fly_self_subsumption (eliminator, d, -pivot);
+    return false;
+  }
+
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether the number of non-tautological resolvents on 'pivot' is
+// smaller or equal to the number of clauses with 'pivot' or '-pivot'.  This
+// is the main criteria of bounded variable elimination.  As a side effect
+// it flushes garbage clauses with that variable, sorts its occurrence lists
+// (smallest clauses first) and also negates pivot if it has more positive
+// than negative occurrences.
+
+bool
+Internal::elim_resolvents_are_bounded (Eliminator & eliminator, int pivot)
+{
+  const bool substitute = !eliminator.gates.empty ();
+  if (substitute) LOG ("trying to substitute %d", pivot);
+
+  stats.elimtried++;
+
+  assert (!unsat);
+  assert (active (pivot));
+
+  const Occs & ps = occs (pivot);
+  const Occs & ns = occs (-pivot);
+  const int64_t pos = ps.size ();
+  const int64_t neg = ns.size ();
+  if (!pos || !neg) return lim.elimbound >= 0;
+  const int64_t bound = pos + neg + lim.elimbound;
+
+  LOG ("checking number resolvents on %d bounded by "
+    "%" PRId64 " = %" PRId64 " + %" PRId64 " + %" PRId64,
+    pivot, bound, pos, neg, lim.elimbound);
+
+  // Try all resolutions between a positive occurrence (outer loop) of
+  // 'pivot' and a negative occurrence of 'pivot' (inner loop) as long the
+  // bound on non-tautological resolvents is not hit and the size of the
+  // generated resolvents does not exceed the resolvent clause size limit.
+
+  int64_t resolvents = 0;          // Non-tautological resolvents.
+
+  for (const auto & c : ps) {
+    assert (!c->redundant);
+    if (c->garbage) continue;
+    for (const auto & d : ns) {
+      assert (!d->redundant);
+      if (d->garbage) continue;
+      if (substitute && c->gate == d->gate) continue;
+      stats.elimrestried++;
+      if (resolve_clauses (eliminator, c, pivot, d, true)) {
+        resolvents++;
+        int size = clause.size ();
+        clause.clear ();
+        LOG ("now at least %" PRId64
+          " non-tautological resolvents on pivot %d",
+          resolvents, pivot);
+        if (size > opts.elimclslim) {
+          LOG ("resolvent size %d too big after %" PRId64
+            " resolvents on %d",
+            size, resolvents, pivot);
+          return false;
+        }
+        if (resolvents > bound) {
+          LOG ("too many non-tautological resolvents on %d", pivot);
+          return false;
+        }
+      } else if (unsat) return false;
+      else if (val (pivot)) return false;
+    }
+  }
+
+  LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents",
+    resolvents, bound);
+
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+// Add all resolvents on 'pivot' and connect them.
+
+inline void
+Internal::elim_add_resolvents (Eliminator & eliminator, int pivot) {
+
+  const bool substitute = !eliminator.gates.empty ();
+  if (substitute) {
+    LOG ("substituting pivot %d by resolving with %zd gate clauses",
+      pivot, eliminator.gates.size ());
+    stats.elimsubst++;
+  }
+
+  LOG ("adding all resolvents on %d", pivot);
+
+  assert (!val (pivot));
+  assert (!flags (pivot).eliminated ());
+
+  const Occs & ps = occs (pivot);
+  const Occs & ns = occs (-pivot);
+
+  int64_t resolvents = 0;
+
+  for (auto & c : ps) {
+    if (unsat) break;
+    if (c->garbage) continue;
+    for (auto & d : ns) {
+      if (unsat) break;
+      if (d->garbage) continue;
+      if (substitute && c->gate == d->gate) continue;
+      if (!resolve_clauses (eliminator, c, pivot, d, false)) continue;
+      Clause * r = new_resolved_irredundant_clause ();
+      elim_update_added_clause (eliminator, r);
+      eliminator.enqueue (r);
+      clause.clear ();
+      resolvents++;
+
+    }
+  }
+
+  LOG ("added %" PRId64 " resolvents to eliminate %d", resolvents, pivot);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Remove clauses with 'pivot' and '-pivot' by marking them as garbage and
+// push them on the extension stack.
+
+void
+Internal::mark_eliminated_clauses_as_garbage (Eliminator & eliminator,
+                                              int pivot)
+{
+  assert (!unsat);
+
+  LOG ("marking irredundant clauses with %d as garbage", pivot);
+
+  const int64_t substitute = eliminator.gates.size ();
+  if (substitute)
+    LOG ("pushing %" PRId64 " gate clauses on extension stack", substitute);
+
+  int64_t pushed = 0;
+
+  Occs & ps = occs (pivot);
+  for (const auto & c : ps) {
+    if (c->garbage) continue;
+    mark_garbage (c);
+    assert (!c->redundant);
+    if (!substitute || c->gate) {
+      external->push_clause_on_extension_stack (c, pivot);
+      pushed++;
+    }
+    elim_update_removed_clause (eliminator, c, pivot);
+  }
+  erase_occs (ps);
+
+  LOG ("marking irredundant clauses with %d as garbage", -pivot);
+
+  Occs & ns = occs (-pivot);
+  for (const auto & d : ns) {
+    if (d->garbage) continue;
+    mark_garbage (d);
+    assert (!d->redundant);
+    if (!substitute || d->gate) {
+      external->push_clause_on_extension_stack (d, -pivot);
+      pushed++;
+    }
+    elim_update_removed_clause (eliminator, d, -pivot);
+  }
+  erase_occs (ns);
+
+  if (substitute) assert (pushed <= substitute);
+
+  // Unfortunately, we can not use the trick by Niklas Soerensson anymore,
+  // which avoids saving all clauses on the extension stack.  This would
+  // break our new incremental 'restore' logic.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to eliminate 'pivot' by bounded variable elimination.
+
+void
+Internal::try_to_eliminate_variable (Eliminator & eliminator, int pivot) {
+
+  if (!active (pivot)) return;
+  assert (!frozen (pivot));
+
+  // First flush garbage clauses.
+  //
+  int64_t pos = flush_occs (pivot);
+  int64_t neg = flush_occs (-pivot);
+
+  if (pos > neg) { pivot = -pivot; swap (pos, neg); }
+  LOG ("pivot %d occurs positively %" PRId64 " times and negatively %" PRId64 " times",
+    pivot, pos, neg);
+  assert (!eliminator.schedule.contains (abs (pivot)));
+  assert (pos <= neg);
+
+  if (pos && neg > opts.elimocclim) {
+    LOG ("too many occurrences thus not eliminated %d", pivot);
+    assert (!eliminator.schedule.contains (abs (pivot)));
+    return;
+  }
+
+  LOG ("trying to eliminate %d", pivot);
+  assert (!flags (pivot).eliminated ());
+
+  // Sort occurrence lists, such that shorter clauses come first.
+  Occs & ps = occs (pivot);
+  stable_sort (ps.begin (), ps.end (), clause_smaller_size ());
+  Occs & ns = occs (-pivot);
+  stable_sort (ns.begin (), ns.end (), clause_smaller_size ());
+
+  if (pos) find_gate_clauses (eliminator, pivot);
+
+  if (!unsat && !val (pivot)) {
+    if (elim_resolvents_are_bounded (eliminator, pivot)) {
+      LOG ("number of resolvents on %d are bounded", pivot);
+      elim_add_resolvents (eliminator, pivot);
+      if (!unsat) mark_eliminated_clauses_as_garbage (eliminator, pivot);
+      if (active (pivot)) mark_eliminated (pivot);
+    } else LOG ("too many resolvents on %d so not eliminated", pivot);
+  }
+
+  unmark_gate_clauses (eliminator);
+  elim_backward_clauses (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+void
+Internal::mark_redundant_clauses_with_eliminated_variables_as_garbage () {
+  for (const auto & c : clauses) {
+    if (c->garbage || !c->redundant) continue;
+    bool clean = true;
+    for (const auto & lit : *c) {
+      Flags & f = flags (lit);
+      if (f.eliminated ()) { clean = false; break; }
+      if (f.pure ()) { clean = false; break; }
+    }
+    if (!clean) mark_garbage (c);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// This function performs one round of bounded variable elimination and
+// returns the number of eliminated variables. The additional result
+// 'completed' is true if this elimination round ran to completion (all
+// variables have been tried).  Otherwise it was asynchronously terminated
+// or the resolution limit was hit.
+
+int Internal::elim_round (bool & completed) {
+
+  assert (opts.elim);
+  assert (!unsat);
+
+  START_SIMPLIFIER (elim, ELIM);
+  stats.elimrounds++;
+
+  last.elim.marked = stats.mark.elim;
+  assert (!level);
+
+  int64_t resolution_limit;
+
+  if (opts.elimlimited) {
+    int64_t delta = stats.propagations.search;
+    delta *= 1e-3 * opts.elimreleff;
+    if (delta < opts.elimineff) delta = opts.elimineff;
+    if (delta > opts.elimaxeff) delta = opts.elimaxeff;
+    delta = max (delta, (int64_t) 2l * active ());
+
+    PHASE ("elim-round", stats.elimrounds,
+      "limit of %" PRId64 " resolutions", delta);
+
+     resolution_limit = stats.elimres + delta;
+  } else {
+    PHASE ("elim-round", stats.elimrounds, "resolutions unlimited");
+    resolution_limit = LONG_MAX;
+  }
+
+  init_noccs ();
+
+  // First compute the number of occurrences of each literal and at the same
+  // time mark satisfied clauses and update 'elim' flags of variables in
+  // clauses with root level assigned literals (both false and true).
+  //
+  for (const auto & c : clauses) {
+    if (c->garbage || c->redundant) continue;
+    bool satisfied = false, falsified = false;
+    for (const auto & lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) satisfied = true;
+      else if (tmp < 0) falsified = true;
+      else assert (active (lit));
+    }
+    if (satisfied) mark_garbage (c);     // forces more precise counts
+    else {
+      for (const auto & lit : *c) {
+        if (!active (lit)) continue;
+        if (falsified) mark_elim (lit);  // simulate unit propagation
+        noccs (lit)++;
+      }
+    }
+  }
+
+  init_occs ();
+
+  Eliminator eliminator (this);
+  ElimSchedule & schedule = eliminator.schedule;
+
+  // Now find elimination candidates which occurred in clauses removed since
+  // the last time we ran bounded variable elimination, which in turned
+  // triggered their 'elim' bit to be set.
+  //
+  for (auto idx : vars) {
+    if (!active (idx)) continue;
+    if (frozen (idx)) continue;
+    if (!flags (idx).elim) continue;
+    flags (idx).elim = false;
+    LOG ("scheduling %d for elimination initially", idx);
+    schedule.push_back (idx);
+  }
+
+  schedule.shrink ();
+
+#ifndef QUIET
+  int64_t scheduled = schedule.size ();
+#endif
+
+  PHASE ("elim-round", stats.elimrounds,
+    "scheduled %" PRId64 " variables %.0f%% for elimination",
+    scheduled, percent (scheduled, active ()));
+
+  // Connect irredundant clauses.
+  //
+  for (const auto & c : clauses)
+    if (!c->garbage && !c->redundant)
+      for (const auto & lit : *c)
+        if (active (lit))
+          occs (lit).push_back (c);
+
+#ifndef QUIET
+  const int64_t old_resolutions = stats.elimres;
+#endif
+  const int old_eliminated = stats.all.eliminated;
+  const int old_fixed = stats.all.fixed;
+
+  // Limit on garbage bytes during variable elimination. If the limit is hit
+  // a garbage collection is performed.
+  //
+  const int64_t garbage_limit = (2*stats.irrbytes/3) + (1<<20);
+
+  // Main loops tries to eliminate variables according to the schedule. The
+  // schedule is updated dynamically and variables are potentially
+  // rescheduled to be tried again if they occur in a removed clause.
+  //
+#ifndef QUIET
+  int64_t tried = 0;
+#endif
+  while (!unsat &&
+         !terminated_asynchronously () &&
+         stats.elimres <= resolution_limit &&
+         !schedule.empty ()) {
+    int idx = schedule.front ();
+    schedule.pop_front ();
+    flags (idx).elim = false;
+    try_to_eliminate_variable (eliminator, idx);
+#ifndef QUIET
+    tried++;
+#endif
+    if (stats.garbage <= garbage_limit) continue;
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+    garbage_collection ();
+  }
+
+  // If the schedule is empty all variables have been tried (even
+  // rescheduled ones).  Otherwise asynchronous termination happened or we
+  // ran into the resolution limit (or derived unsatisfiability).
+  //
+  completed = !schedule.size ();
+
+  PHASE ("elim-round", stats.elimrounds,
+    "tried to eliminate %" PRId64 " variables %.0f%% (%zd remain)",
+    tried, percent (tried, scheduled), schedule.size ());
+
+  schedule.erase ();
+
+  // Collect potential literal clause instantiation pairs, which needs full
+  // occurrence lists and thus we have it here before resetting them.
+  //
+  Instantiator instantiator;
+  if (!unsat &&
+      !terminated_asynchronously () &&
+      opts.instantiate)
+    collect_instantiation_candidates (instantiator);
+
+  reset_occs ();
+  reset_noccs ();
+
+  // Mark all redundant clauses with eliminated variables as garbage.
+  //
+  if (!unsat)
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+
+  int eliminated = stats.all.eliminated - old_eliminated;
+#ifndef QUIET
+  int64_t resolutions = stats.elimres - old_resolutions;
+  PHASE ("elim-round", stats.elimrounds,
+    "eliminated %d variables %.0f%% in %" PRId64 " resolutions",
+    eliminated, percent (eliminated, scheduled), resolutions);
+#endif
+
+  last.elim.subsumephases = stats.subsumephases;
+  const int units = stats.all.fixed - old_fixed;
+  report ('e', !opts.reportall && !(eliminated + units));
+  STOP_SIMPLIFIER (elim, ELIM);
+
+  if (!unsat &&
+      !terminated_asynchronously () &&
+      instantiator)                     // Do we have candidate pairs?
+    instantiate (instantiator);
+
+  return eliminated;                    // non-zero if successful
+}
+
+/*------------------------------------------------------------------------*/
+
+// Increase elimination bound (additional clauses allowed during variable
+// elimination), which is triggered if elimination with last bound completed
+// (including no new subsumptions).  This was pioneered by GlueMiniSAT in
+// the SAT Race 2015 and then picked up Chanseok Oh in his COMinisatPS
+// solver, which in turn is used in the Maple series of SAT solvers.
+// The bound is no increased if the maximum bound is reached.
+
+void Internal::increase_elimination_bound () {
+
+  if (lim.elimbound >= opts.elimboundmax) return;
+
+       if (lim.elimbound < 0) lim.elimbound = 0;
+  else if (!lim.elimbound)    lim.elimbound = 1;
+  else                        lim.elimbound *= 2;
+
+  if (lim.elimbound > opts.elimboundmax)
+    lim.elimbound = opts.elimboundmax;
+
+  PHASE ("elim-phase", stats.elimphases,
+    "new elimination bound %" PRId64 "", lim.elimbound);
+
+  // Now reschedule all active variables for elimination again.
+  //
+  int count = 0;
+  for (auto idx : vars) {
+    if (!active (idx)) continue;
+    if (flags (idx).elim) continue;
+    mark_elim (idx);
+    count++;
+  }
+  LOG ("marked %d variables as elimination candidates", count);
+
+  report ('^');
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim (bool update_limits) {
+
+  if (unsat) return;
+  if (level) backtrack ();
+  if (!propagate ()) { learn_empty_clause (); return; }
+
+  stats.elimphases++;
+  PHASE ("elim-phase", stats.elimphases,
+    "starting at most %d elimination rounds",
+    opts.elimrounds);
+
+#ifndef QUIET
+  int old_active_variables = active ();
+  int old_eliminated = stats.all.eliminated;
+#endif
+
+  // Make sure there was a complete subsumption phase since last
+  // elimination including vivification etc.
+  //
+  if (last.elim.subsumephases == stats.subsumephases)
+    subsume (update_limits);
+
+  reset_watches ();             // saves lots of memory
+
+  // Alternate one round of bounded variable elimination ('elim_round') and
+  // subsumption ('subsume_round'), blocked ('block') and covered clause
+  // elimination ('cover') until nothing changes, or the round limit is hit.
+  // The loop also aborts early if no variable could be eliminated, the
+  // empty clause is resolved, it is asynchronously terminated or a
+  // resolution limit is hit.
+
+  // This variable determines whether the whole loop of this bounded
+  // variable elimination phase ('elim') ran until completion.  This
+  // potentially triggers an incremental increase of the elimination bound.
+  //
+  bool phase_complete = false;
+
+  int round = 1;
+
+  while (!unsat &&
+         !phase_complete &&
+         !terminated_asynchronously ()) {
+
+    bool round_complete;
+
+#ifndef QUIET
+    int eliminated =
+#endif
+    elim_round (round_complete);
+
+    if (!round_complete) {
+      PHASE ("elim-phase", stats.elimphases,
+        "last round %d incomplete %s",
+        round, eliminated ? "but successful" : "and unsuccessful");
+      assert (!phase_complete);
+      break;
+    }
+
+    if (round++ >= opts.elimrounds) {
+      PHASE ("elim-phase", stats.elimphases,
+        "round limit %d hit (%s)", round-1,
+        eliminated ? "though last round successful" :
+                     "last round unsuccessful anyhow");
+      assert (!phase_complete);
+      break;
+    }
+
+    // Prioritize 'subsumption' over blocked and covered clause elimination.
+
+    if (subsume_round ()) continue;
+    if (block ()) continue;
+    if (cover ()) continue;
+
+    // Was not able to generate new variable elimination candidates after
+    // variable elimination round, neither through subsumption, nor blocked,
+    // nor covered clause elimination.
+    //
+    PHASE ("elim-phase", stats.elimphases,
+      "no new variable elimination candidates");
+
+    assert (round_complete);
+    phase_complete = true;
+  }
+
+  if (phase_complete) {
+    stats.elimcompleted++;
+    PHASE ("elim-phase", stats.elimphases,
+      "fully completed elimination %" PRId64
+      " at elimination bound %" PRId64 "",
+      stats.elimcompleted, lim.elimbound);
+  } else {
+    PHASE ("elim-phase", stats.elimphases,
+      "incomplete elimination %" PRId64
+      " at elimination bound %" PRId64 "",
+      stats.elimcompleted + 1, lim.elimbound);
+  }
+
+  init_watches ();
+  connect_watches ();
+
+  if (unsat) LOG ("elimination derived empty clause");
+  else if (propagated < trail.size ()) {
+    LOG ("elimination produced %zd units",
+      (size_t)(trail.size () - propagated));
+    if (!propagate ()) {
+      LOG ("propagating units after elimination results in empty clause");
+      learn_empty_clause ();
+    }
+  }
+
+  // If we ran variable elimination until completion we increase the
+  // variable elimination bound and reschedule elimination of all variables.
+  //
+  if (phase_complete) increase_elimination_bound ();
+
+#ifndef QUIET
+  int eliminated = stats.all.eliminated - old_eliminated;
+  PHASE ("elim-phase", stats.elimphases,
+    "eliminated %d variables %.2f%%",
+    eliminated, percent (eliminated, old_active_variables));
+#endif
+
+  if (!update_limits) return;
+
+  int64_t delta = scale (opts.elimint * (stats.elimphases + 1));
+  lim.elim = stats.conflicts + delta;
+
+  PHASE ("elim-phase", stats.elimphases,
+    "new limit at %" PRId64 " conflicts after %" PRId64 " conflicts",
+    lim.elim, delta);
+
+  last.elim.fixed = stats.all.fixed;
+}
+
+}
diff --git a/hCaD_V2/src/elim.hpp b/hCaD_V2/src/elim.hpp
new file mode 100644
index 0000000..a362a1a
--- /dev/null
+++ b/hCaD_V2/src/elim.hpp
@@ -0,0 +1,37 @@
+#ifndef _elim_hpp_INCLUDED
+#define _elim_hpp_INCLUDED
+
+#include "heap.hpp"     // Alphabetically after 'elim.hpp'.
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct elim_more {
+  Internal * internal;
+  elim_more (Internal * i) : internal (i) { }
+  bool operator () (unsigned a, unsigned b);
+};
+
+typedef heap<elim_more> ElimSchedule;
+
+struct Eliminator {
+
+  Internal * internal;
+  ElimSchedule schedule;
+
+  Eliminator (Internal * i) : internal (i), schedule (elim_more (i)) { }
+  ~Eliminator ();
+
+  queue<Clause*> backward;
+
+  Clause * dequeue ();
+  void enqueue (Clause *);
+
+  vector<Clause *> gates;
+  vector<int> marked;
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/ema.cpp b/hCaD_V2/src/ema.cpp
new file mode 100644
index 0000000..c61efbd
--- /dev/null
+++ b/hCaD_V2/src/ema.cpp
@@ -0,0 +1,95 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Updating an exponential moving average is placed here since we want to
+// log both updates and phases of initialization, thus need 'LOG'.
+//
+// We now use initialization bias correction as in the ADAM method
+// [KingmaBa-ICLR'15] instead of our ad-hoc initialization method used
+// before.  Our old variant used exponentially decreasing alphas:
+//
+//   1,
+//   1/2, 1/2,
+//   1/4, 1/4, 1/4, 1/4
+//   1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8,
+//   ...
+//   2^-n, ..., 2^-n                          'n' times
+//   alpha, alpha, ...                        now 'alpha' forever.
+//
+//   where 2^-n is the smallest negative power of two above 'alpha'
+//
+// This old method is better than the initializations described in our
+// [BiereFroehlich-POS'15] paper and actually faster than the ADAM method,
+// but less precise.  This old method, which we consider obsolete but it
+// could still be useful for implementations relying on integers instead of
+// floating points thus only needs shifts and integer arithmetic.
+//
+// Our new method for unbiased initialization of the exponential averages
+// works as follows.  First the biased moving average is computed as usual.
+// Note that (as already before) we use the simpler equation
+//
+//   new_biased = old_biased + alpha * (y - old_biased);
+//
+// which in principle (and thus easy to remember) can be implemented as
+//
+//   biased += alpha * (y - biased);
+//
+// The original formulation in the ADAM paper (with 'alpha = 1 - beta') is
+//
+//   new_biased = beta * old_biased + (1 - beta) * y
+//
+// To show that these are equivalent (modulo floating point issues)
+// consider the following equivalent expressions:
+//
+//   old_biased + alpha * (y - old_biased)
+//   old_biased + alpha * y - alpha * old_biased
+//   (1 - alpha) * old_biased + alpha * y
+//   beta * old_biased + (1 - beta) * y
+//
+// The real new idea taken from the ADAM paper is however to fix the biased
+// moving average with a correction term '1.0 / (1.0 - pow (beta, updated))'
+// by multiplication to obtain an unbiased moving average (called simply
+// 'value' in our 'code').  In order to avoid computing 'pow' every time, we
+// use 'exp' which is multiplied in every update with 'beta'.
+
+void EMA::update (Internal * internal, double y, const char * name) {
+#ifdef LOGGING
+  updated++;
+  const double old_value = value;
+#endif
+  const double old_biased = biased;
+  const double delta = y - old_biased;
+  const double scaled_delta = alpha * delta;
+  const double new_biased = old_biased + scaled_delta;
+  LOG ("update %" PRIu64 " of biased %s EMA %g with %g (delta %g) "
+       "yields %g (scaled delta %g)",
+       updated, name, old_biased, y, delta, new_biased, scaled_delta);
+  biased = new_biased;
+  const double old_exp = exp;
+  double new_exp, div, new_value;
+  if (old_exp) {
+    new_exp = old_exp * beta;
+    assert (new_exp < 1);
+    exp = new_exp;
+    div = 1 - new_exp;
+    assert (div > 0);
+    new_value = new_biased / div;
+  } else {
+    new_value = new_biased;
+#ifdef LOGGING
+    new_exp = 0;
+    div = 1;
+#endif
+  }
+  value = new_value;
+  LOG ("update %" PRIu64 " of corrected %s EMA %g with %g (delta %g) "
+       "yields %g (exponent %g, divisor %g)" ,
+       updated, name, old_value, y, delta, new_value, new_exp, div);
+#ifndef LOGGING
+  (void) internal;
+  (void) name;
+#endif
+}
+
+}
diff --git a/hCaD_V2/src/ema.hpp b/hCaD_V2/src/ema.hpp
new file mode 100644
index 0000000..3a6f8cd
--- /dev/null
+++ b/hCaD_V2/src/ema.hpp
@@ -0,0 +1,61 @@
+#ifndef _ema_hpp_INCLUDED
+#define _ema_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Internal;
+
+// This is a more complex generic exponential moving average class to
+// support more robust initialization (see comments in the 'update'
+// implementation).
+
+struct EMA {
+
+#ifdef LOGGING
+  uint64_t updated;
+#endif
+  double value;         // unbiased (corrected) moving average
+  double biased;        // biased initialized moving average
+  double alpha;         // input scaling with 'alpha = 1 - beta'
+  double beta;          // decay of 'biased' with 'beta = 1 - alpha'
+  double exp;           // 'exp = pow (beta, updated)'
+
+  EMA () :
+#ifdef LOGGING
+  updated (0),
+#endif
+  value (0), biased (0), alpha (0), beta (0), exp (0) { }
+
+  EMA (double a) :
+#ifdef LOGGING
+    updated (0),
+#endif
+    value (0), biased (0), alpha (a), beta (1 - a), exp (!!beta)
+  {
+    assert (beta >= 0);
+  }
+
+  operator double () const { return value; }
+  void update (Internal *, double y, const char * name);
+};
+
+}
+
+/*------------------------------------------------------------------------*/
+
+// Compact average update and initialization macros for better logging.
+
+#define UPDATE_AVERAGE(A,Y) \
+do { A.update (internal, (Y), #A); } while (0)
+
+#define INIT_EMA(E,WINDOW) \
+do { \
+  assert ((WINDOW) >= 1); \
+  double ALPHA = 1.0 / (double)(WINDOW); \
+  E = EMA (ALPHA); \
+  LOG ("init " #E " EMA target alpha %g window %d", ALPHA, (int)WINDOW); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/hCaD_V2/src/extend.cpp b/hCaD_V2/src/extend.cpp
new file mode 100644
index 0000000..d84ba95
--- /dev/null
+++ b/hCaD_V2/src/extend.cpp
@@ -0,0 +1,208 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void External::push_zero_on_extension_stack () {
+  extension.push_back (0);
+  LOG ("pushing 0 on extension stack");
+}
+
+void External::push_clause_literal_on_extension_stack (int ilit) {
+  assert (ilit);
+  const int elit = internal->externalize (ilit);
+  assert (elit);
+  extension.push_back (elit);
+  LOG ("pushing clause literal %d on extension stack (internal %d)",
+    elit, ilit);
+}
+
+void External::push_witness_literal_on_extension_stack (int ilit) {
+  assert (ilit);
+  const int elit = internal->externalize (ilit);
+  assert (elit);
+  extension.push_back (elit);
+  LOG ("pushing witness literal %d on extension stack (internal %d)",
+    elit, ilit);
+  if (marked (witness, elit)) return;
+  LOG ("marking witness %d", elit);
+  mark (witness, elit);
+}
+
+// The extension stack allows to reconstruct a satisfying assignment for the
+// original formula after removing eliminated clauses.  This was pioneered
+// by Niklas Soerensson in MiniSAT and for instance is described in our
+// inprocessing paper, published at IJCAR'12.  This first function adds a
+// clause to this stack.  First the blocking or eliminated literal is added,
+// and then the rest of the clause.
+
+void External::push_clause_on_extension_stack (Clause * c) {
+  internal->stats.weakened++;
+  internal->stats.weakenedlen += c->size;
+  push_zero_on_extension_stack ();
+  for (const auto & lit : *c)
+    push_clause_literal_on_extension_stack (lit);
+}
+
+void External::push_clause_on_extension_stack (Clause * c, int pivot) {
+  push_zero_on_extension_stack ();
+  push_witness_literal_on_extension_stack (pivot);
+  push_clause_on_extension_stack (c);
+}
+
+void
+External::push_binary_clause_on_extension_stack (int pivot, int other) {
+  internal->stats.weakened++;
+  internal->stats.weakenedlen += 2;
+  push_zero_on_extension_stack ();
+  push_witness_literal_on_extension_stack (pivot);
+  push_zero_on_extension_stack ();
+  push_clause_literal_on_extension_stack (pivot);
+  push_clause_literal_on_extension_stack (other);
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::push_external_clause_and_witness_on_extension_stack (
+  const vector<int> & c, const vector<int> & w) {
+  extension.push_back (0);
+  for (const auto & elit : w) {
+    assert (elit != INT_MIN);
+    init (abs (elit));
+    extension.push_back (elit);
+    mark (witness, elit);
+  }
+  extension.push_back (0);
+  for (const auto & elit : c) {
+    assert (elit != INT_MIN);
+    init (abs (elit));
+    extension.push_back (elit);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the actual extension process. It goes backward over the clauses
+// on the extension stack and flips the assignment of one of the blocking
+// literals in the conditional autarky stored before the clause.  In the
+// original algorithm for witness construction for variable elimination and
+// blocked clause removal the conditional autarky consists of a single
+// literal from the removed clause, while in general the autarky witness can
+// contain an arbitrary set of literals.  We are using the more general
+// witness reconstruction here which for instance would also work for
+// super-blocked or set-blocked clauses.
+
+void External::extend () {
+
+  assert (!extended);
+  START (extend);
+  internal->stats.extensions++;
+
+  PHASE ("extend", internal->stats.extensions,
+    "mapping internal %d assignments to %d assignments",
+    internal->max_var, max_var);
+
+  int64_t updated = 0;
+  for (unsigned i = 1; i <= (unsigned) max_var; i++) {
+    const int ilit = e2i[i];
+    if (!ilit) continue;
+    while (i >= vals.size ())
+      vals.push_back (false);
+    vals[i] = (internal->val (ilit) > 0);
+    updated++;
+  }
+  PHASE ("extend", internal->stats.extensions,
+    "updated %" PRId64 " external assignments", updated);
+  PHASE ("extend", internal->stats.extensions,
+    "extending through extension stack of size %zd",
+    extension.size ());
+  const auto begin = extension.begin ();
+  auto i = extension.end ();
+  int64_t flipped = 0;
+  while (i != begin) {
+    bool satisfied = false;
+    int lit;
+    assert (i != begin);
+    while ((lit = *--i)) {
+      if (satisfied) continue;
+      if (ival (lit) > 0) satisfied = true;
+      assert (i != begin);
+    }
+    assert (i != begin);
+    if (satisfied)
+      while (*--i)
+        assert (i != begin);
+    else {
+      while ((lit = *--i)) {
+        const int tmp = ival (lit);             // not 'signed char'!!!
+        if (tmp < 0) {
+          LOG ("flipping blocking literal %d", lit);
+          assert (lit);
+          assert (lit != INT_MIN);
+          int idx = abs (lit);
+          while ((size_t) idx >= vals.size ())
+            vals.push_back (false);
+          vals[idx] = !vals[idx];
+          internal->stats.extended++;
+          flipped++;
+        }
+        assert (i != begin);
+      }
+    }
+  }
+  PHASE ("extend", internal->stats.extensions,
+    "flipped %" PRId64 " literals during extension", flipped);
+  extended = true;
+  LOG ("extended");
+  STOP (extend);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool External::traverse_witnesses_backward (WitnessIterator & it) {
+  if (internal->unsat) return true;
+  vector<int> clause, witness;
+  const auto begin = extension.begin ();
+  auto i = extension.end ();
+  while (i != begin) {
+    int lit;
+    while ((lit = *--i))
+      clause.push_back (lit);
+    while ((lit = *--i))
+      witness.push_back (lit);
+    reverse (clause.begin (), clause.end ());
+    reverse (witness.begin (), witness.end ());
+    if (!it.witness (clause, witness))
+      return false;
+    clause.clear ();
+    witness.clear ();
+  }
+  return true;
+}
+
+bool External::traverse_witnesses_forward (WitnessIterator & it) {
+  if (internal->unsat) return true;
+  vector<int> clause, witness;
+  const auto end = extension.end ();
+  auto i = extension.begin ();
+  if (i != end) {
+    int lit = *i++;
+    do {
+      assert (!lit), (void) lit;
+      while ((lit = *i++))
+        witness.push_back (lit);
+      assert (!lit);
+      assert (i != end);
+      while (i != end && (lit = *i++))
+        clause.push_back (lit);
+      if (!it.witness (clause, witness))
+        return false;
+      clause.clear ();
+      witness.clear ();
+    } while (i != end);
+  }
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+}
diff --git a/hCaD_V2/src/external.cpp b/hCaD_V2/src/external.cpp
new file mode 100644
index 0000000..73725d7
--- /dev/null
+++ b/hCaD_V2/src/external.cpp
@@ -0,0 +1,541 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+External::External (Internal * i)
+:
+  internal (i),
+  max_var (0),
+  vsize (0),
+  extended (false),
+  terminator (0),
+  learner (0),
+  solution (0),
+  vars (max_var)
+{
+  assert (internal);
+  assert (!internal->external);
+  internal->external = this;
+}
+
+External::~External () {
+  if (solution) delete [] solution;
+}
+
+void External::enlarge (int new_max_var) {
+
+  assert (!extended);
+
+  size_t new_vsize = vsize ? 2*vsize : 1 + (size_t) new_max_var;
+  while (new_vsize <= (size_t) new_max_var) new_vsize *= 2;
+  LOG ("enlarge external size from %zd to new size %zd", vsize, new_vsize);
+  vsize = new_vsize;
+}
+
+void External::init (int new_max_var) {
+  assert (!extended);
+  if (new_max_var <= max_var) return;
+  int new_vars = new_max_var - max_var;
+  int old_internal_max_var = internal->max_var;
+  int new_internal_max_var = old_internal_max_var + new_vars;
+  internal->init_vars (new_internal_max_var);
+  if ((size_t) new_max_var >= vsize) enlarge (new_max_var);
+  LOG ("initialized %d external variables", new_vars);
+  if (!max_var) {
+    assert (e2i.empty ());
+    e2i.push_back (0);
+    assert (internal->i2e.empty ());
+    internal->i2e.push_back (0);
+  } else {
+    assert (e2i.size () == (size_t) max_var + 1);
+    assert (internal->i2e.size () == (size_t) old_internal_max_var + 1);
+  }
+  unsigned iidx = old_internal_max_var + 1, eidx;
+  for (eidx = max_var + 1u;
+       eidx <= (unsigned) new_max_var;
+       eidx++, iidx++) {
+    LOG ("mapping external %u to internal %u", eidx, iidx);
+    assert (e2i.size () == eidx);
+    e2i.push_back (iidx);
+    internal->i2e.push_back (eidx);
+    assert (internal->i2e[iidx] == (int) eidx);
+    assert (e2i[eidx] == (int) iidx);
+  }
+  if (internal->opts.checkfrozen)
+    while (new_max_var >= (int64_t) moltentab.size ())
+      moltentab.push_back (false);
+  assert (iidx == (size_t) new_internal_max_var + 1);
+  assert (eidx == (size_t) new_max_var + 1);
+  max_var = new_max_var;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::reset_assumptions () {
+  assumptions.clear ();
+  internal->reset_assumptions ();
+}
+
+void External::reset_extended () {
+  if (!extended) return;
+  LOG ("reset extended");
+  extended = false;
+}
+
+void External::reset_limits () {
+  internal->reset_limits ();
+}
+
+/*------------------------------------------------------------------------*/
+
+int External::internalize (int elit) {
+  int ilit;
+  if (elit) {
+    assert (elit != INT_MIN);
+    const int eidx = abs (elit);
+    if (eidx > max_var) init (eidx);
+    ilit = e2i [eidx];
+    if (elit < 0) ilit = -ilit;
+    if (!ilit) {
+      assert (internal->max_var < INT_MAX);
+      ilit = internal->max_var + 1u;
+      internal->init_vars (ilit);
+      e2i[eidx] = ilit;
+      LOG ("mapping external %d to internal %d", eidx, ilit);
+      e2i[eidx] = ilit;
+      internal->i2e.push_back (eidx);
+      assert (internal->i2e[ilit] == eidx);
+      assert (e2i[eidx] == ilit);
+      if (elit < 0) ilit = -ilit;
+    }
+    if (internal->opts.checkfrozen) {
+      assert (eidx < (int64_t) moltentab.size ());
+      if (moltentab[eidx])
+        FATAL ("can not reuse molten literal %d", eidx);
+    }
+    Flags & f = internal->flags (ilit);
+    if (f.status == Flags::UNUSED) internal->mark_active (ilit);
+    else if (f.status != Flags::ACTIVE &&
+             f.status != Flags::FIXED) internal->reactivate (ilit);
+    if (!marked (tainted, elit) && marked (witness, -elit)) {
+      assert (!internal->opts.checkfrozen);
+      LOG ("marking tainted %d", elit);
+      mark (tainted, elit);
+    }
+  } else ilit = 0;
+  return ilit;
+}
+
+void External::add (int elit) {
+  assert (elit != INT_MIN);
+  reset_extended ();
+  if (internal->opts.check &&
+      (internal->opts.checkwitness || internal->opts.checkfailed))
+    original.push_back (elit);
+  const int ilit = internalize (elit);
+  assert (!elit == !ilit);
+  if (elit) LOG ("adding external %d as internal %d", elit, ilit);
+  internal->add_original_lit (ilit);
+}
+
+void External::assume (int elit) {
+  assert (elit);
+  reset_extended ();
+  assumptions.push_back (elit);
+  const int ilit = internalize (elit);
+  assert (ilit);
+  LOG ("assuming external %d as internal %d", elit, ilit);
+  internal->assume (ilit);
+}
+
+bool External::failed (int elit) {
+  assert (elit);
+  assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var) return 0;
+  int ilit = e2i[eidx];
+  if (!ilit) return 0;
+  if (elit < 0) ilit = -ilit;
+  return internal->failed (ilit);
+}
+
+void External::phase (int elit) {
+  assert (elit);
+  assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var) return;
+  int ilit = e2i[eidx];
+  if (!ilit) return;
+  if (elit < 0) ilit = -ilit;
+  internal->phase (ilit);
+}
+
+void External::unphase (int elit) {
+  assert (elit);
+  assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var) return;
+  int ilit = e2i[eidx];
+  if (!ilit) return;
+  if (elit < 0) ilit = -ilit;
+  internal->unphase (ilit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Internal checker if 'solve' claims the formula to be satisfiable.
+
+void External::check_satisfiable () {
+  LOG ("checking satisfiable");
+  if (internal->opts.checkwitness)
+    check_assignment (&External::ival);
+  if (internal->opts.checkassumptions && !assumptions.empty ())
+    check_assumptions_satisfied ();
+}
+
+// Internal checker if 'solve' claims formula to be unsatisfiable.
+
+void External::check_unsatisfiable () {
+  LOG ("checking unsatisfiable");
+  if (internal->opts.checkfailed && !assumptions.empty ())
+    check_assumptions_failing ();
+}
+
+// Check result of 'solve' to be correct.
+
+void External::check_solve_result (int res) {
+  if (!internal->opts.check) return;
+  if (res == 10) check_satisfiable ();
+  if (res == 20) check_unsatisfiable ();
+}
+
+// Prepare checking that completely molten literals are not used as argument
+// of 'add' or 'assume', which is invalid under freezing semantics.  This
+// case would be caught by our 'restore' implementation so is only needed
+// for checking the deprecated 'freeze' semantics.
+
+void External::update_molten_literals () {
+  if (!internal->opts.checkfrozen) return;
+  assert ((size_t) max_var + 1 == moltentab.size ());
+  int registered = 0, molten = 0;
+  for (auto lit : vars) {
+    if (moltentab[lit]) {
+      LOG ("skipping already molten literal %d", lit);
+      molten++;
+    } else if (frozen (lit))
+      LOG ("skipping currently frozen literal %d", lit);
+    else {
+      LOG ("new molten literal %d", lit);
+      moltentab[lit] = true;
+      registered++;
+      molten++;
+    }
+  }
+  LOG ("registered %d new molten literals", registered);
+  LOG ("reached in total %d molten literals", molten);
+}
+
+int External::solve (bool preprocess_only) {
+  reset_extended ();
+  update_molten_literals ();
+  int res = internal->solve (preprocess_only);
+  if (res == 10) extend ();
+  check_solve_result (res);
+  reset_limits ();
+  return res;
+}
+
+void External::terminate () { internal->terminate (); }
+
+int External::lookahead () {
+  reset_extended ();
+  update_molten_literals ();
+  int ilit = internal->lookahead ();
+  const int elit = (ilit && ilit != INT_MIN) ? internal->externalize (ilit) : 0;
+  LOG ("lookahead internal %d external %d", ilit, elit);
+  return elit;
+}
+
+CaDiCaL::CubesWithStatus External::generate_cubes (int depth, int min_depth = 0) {
+  reset_extended ();
+  update_molten_literals ();
+  reset_limits ();
+  auto cubes = internal->generate_cubes (depth, min_depth);
+  auto externalize = [this](int ilit) {
+    const int elit = ilit ? internal->externalize (ilit) : 0;
+    MSG ("lookahead internal %d external %d", ilit, elit);
+    return elit;
+  };
+  auto externalize_map = [this, externalize](std::vector<int> cube) {
+    (void) this;
+    MSG("Cube : ");
+    std::for_each(begin(cube), end(cube), externalize);
+  };
+  std::for_each(begin(cubes.cubes), end(cubes.cubes), externalize_map);
+
+  return cubes;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::freeze (int elit) {
+  reset_extended ();
+  int ilit = internalize (elit);
+  unsigned eidx = vidx (elit);
+  while (eidx >= frozentab.size ())
+    frozentab.push_back (0);
+  unsigned & ref = frozentab[eidx];
+  if (ref < UINT_MAX) {
+    ref++;
+    LOG ("external variable %d frozen once and now frozen %u times",
+      eidx, ref);
+  } else
+    LOG ("external variable %d frozen but remains frozen forever", eidx);
+  internal->freeze (ilit);
+}
+
+void External::melt (int elit) {
+  reset_extended ();
+  int ilit = internalize (elit);
+  unsigned eidx = vidx (elit);
+  assert (eidx < frozentab.size ());
+  unsigned & ref = frozentab[eidx];
+  assert (ref > 0);
+  if (ref < UINT_MAX) {
+    if (!--ref)
+      LOG ("external variable %d melted once and now completely melted",
+        eidx);
+    else
+      LOG ("external variable %d melted once but remains frozen %u times",
+        eidx, ref);
+  } else
+    LOG ("external variable %d melted but remains frozen forever", eidx);
+  internal->melt (ilit);
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::check_assignment (int (External::*a)(int) const) {
+
+  // First check all assigned and consistent.
+  //
+  for (auto idx : vars) {
+    if (!(this->*a) (idx)) FATAL ("unassigned variable: %d", idx);
+    if ((this->*a) (idx) != -(this->*a)(-idx))
+      FATAL ("inconsistently assigned literals %d and %d", idx, -idx);
+  }
+
+  // Then check that all (saved) original clauses are satisfied.
+  //
+  bool satisfied = false;
+  const auto end = original.end ();
+  auto start = original.begin (), i = start;
+  int64_t count = 0;
+  for (; i != end; i++) {
+    int lit = *i;
+    if (!lit) {
+      if (!satisfied) {
+        fatal_message_start ();
+        fputs ("unsatisfied clause:\n", stderr);
+        for (auto j = start; j != i; j++)
+          fprintf (stderr, "%d ", *j);
+        fputc ('0', stderr);
+        fatal_message_end ();
+      }
+      satisfied = false;
+      start = i + 1;
+      count++;
+    } else if (!satisfied && (this->*a) (lit) > 0) satisfied = true;
+  }
+  VERBOSE (1,
+    "satisfying assignment checked on %" PRId64 " clauses",
+    count);
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::check_assumptions_satisfied () {
+  for (const auto & lit : assumptions) {
+    // Not 'signed char' !!!!
+    const int tmp = ival (lit);
+    if (tmp < 0) FATAL ("assumption %d falsified", lit);
+    if (!tmp) FATAL ("assumption %d unassigned", lit);
+  }
+  VERBOSE (1,
+    "checked that %zd assumptions are satisfied",
+    assumptions.size ());
+}
+
+void External::check_assumptions_failing () {
+  Solver * checker = new Solver ();
+  checker->prefix ("checker ");
+#ifdef LOGGING
+  if (internal->opts.log) checker->set ("log", true);
+#endif
+  for (const auto & lit : original)
+    checker->add (lit);
+  for (const auto & lit : assumptions) {
+    if (!failed (lit)) continue;
+    LOG ("checking failed literal %d in core", lit);
+    checker->add (lit);
+    checker->add (0);
+  }
+  int res = checker->solve ();
+  if (res != 20) FATAL ("failed assumptions do not form a core");
+  delete checker;
+  VERBOSE (1,
+    "checked that %zd failing assumptions form a core",
+    assumptions.size ());
+}
+
+/*------------------------------------------------------------------------*/
+
+// Traversal of unit clauses is implemented here.
+
+// In principle we want to traverse the clauses of the simplified formula
+// only, particularly eliminated variables should be completely removed.
+// This poses the question what to do with unit clauses.  Should they be
+// considered part of the simplified formula or of the witness to construct
+// solutions for the original formula?  Ideally they should be considered
+// to be part of the witness only, i.e., as they have been simplified away.
+
+// Therefore we distinguish frozen and non-frozen units during clause
+// traversal.  Frozen units are treated as unit clauses while non-frozen
+// units are treated as if they were already eliminated and put on the
+// extension stack as witness clauses.
+
+// Furthermore, eliminating units during 'compact' could be interpreted as
+// variable elimination, i.e., just add the resolvents (remove falsified
+// literals), then drop the clauses with the unit, and push the unit on the
+// extension stack.  This is of course only OK if the user did not freeze
+// that variable (even implicitly during assumptions).
+
+// Thanks go to Fahiem Bacchus for asking why there is a necessity to
+// distinguish these two cases (frozen and non-frozen units).  The answer is
+// that it is not strictly necessary, and this distinction could be avoided
+// by always treating units as remaining unit clauses, thus only using the
+// first of the two following functions and dropping the 'if (!frozen (idx))
+// continue;' check in it.  This has however the down-side that those units
+// are still in the simplified formula and only as units.  I would not
+// consider such a formula as really being 'simplified'. On the other hand
+// if the user explicitly freezes a literal, then it should continue to be in
+// the simplified formula during traversal.  So also only using the second
+// function is not ideal.
+
+// There is however a catch where this solution breaks down (in the sense of
+// producing less optimal results - that is keeping units in the formula
+// which better would be witness clauses).  The problem is with compact
+// preprocessing which removes eliminated but also fixed internal variables.
+// One internal unit (fixed) variable is kept and all the other external
+// literals which became unit are mapped to that internal literal (negated
+// or positively).  Compact is called non-deterministically from the point
+// of the user and thus there is no control on when this happens.  If
+// compact happens those external units are mapped to a single internal
+// literal now and then all share the same 'frozen' counter.   So if the
+// user freezes one of them all in essence get frozen, which in turn then
+// makes a difference in terms of traversing such a unit as unit clause or
+// as unit witness.
+
+bool
+External::traverse_all_frozen_units_as_clauses (ClauseIterator & it)
+{
+  if (internal->unsat) return true;
+
+  vector<int> clause;
+
+  for (auto idx : vars) {
+    if (!frozen (idx)) continue;
+    const int tmp = fixed (idx);
+    if (!tmp) continue;
+    int unit = tmp < 0 ? -idx : idx;
+    clause.push_back (unit);
+    if (!it.clause (clause))
+      return false;
+    clause.clear ();
+  }
+
+  return true;
+}
+
+bool
+External::traverse_all_non_frozen_units_as_witnesses (WitnessIterator & it)
+{
+  if (internal->unsat) return true;
+
+  vector<int> clause_and_witness;
+
+  for (auto idx : vars) {
+    if (frozen (idx)) continue;
+    const int tmp = fixed (idx);
+    if (!tmp) continue;
+    int unit = tmp < 0 ? -idx : idx;
+    clause_and_witness.push_back (unit);
+    if (!it.witness (clause_and_witness, clause_and_witness))
+      return false;
+    clause_and_witness.clear ();
+  }
+
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::copy_flags (External & other) const {
+  const vector<Flags> & this_ftab = internal->ftab;
+  vector<Flags> & other_ftab = other.internal->ftab;
+  const unsigned limit = min (max_var, other.max_var);
+  for (unsigned eidx = 1; eidx <= limit; eidx++) {
+    const int this_ilit = e2i[eidx];
+    if (!this_ilit) continue;
+    const int other_ilit = other.e2i[eidx];
+    if (!other_ilit) continue;
+    if (!internal->active (this_ilit)) continue;
+    if (!other.internal->active (other_ilit)) continue;
+    assert (this_ilit != INT_MIN);
+    assert (other_ilit != INT_MIN);
+    const Flags & this_flags = this_ftab[abs (this_ilit)];
+    Flags & other_flags = other_ftab[abs (other_ilit)];
+    this_flags.copy (other_flags);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::export_learned_empty_clause () {
+  assert (learner);
+  if (learner->learning (0)) {
+    LOG ("exporting learned empty clause");
+    learner->learn (0);
+  } else
+    LOG ("not exporting learned empty clause");
+}
+
+void External::export_learned_unit_clause (int ilit) {
+  assert (learner);
+  if (learner->learning (1)) {
+    LOG ("exporting learned unit clause");
+    const int elit = internal->externalize (ilit);
+    assert (elit);
+    learner->learn (elit);
+    learner->learn (0);
+  } else
+    LOG ("not exporting learned unit clause");
+}
+
+void External::export_learned_large_clause (const vector<int> & clause) {
+  assert (learner);
+  size_t size = clause.size ();
+  assert (size <= (unsigned) INT_MAX);
+  if (learner->learning ((int) size)) {
+    LOG ("exporting learned clause of size %zu", size);
+    for (auto ilit : clause) {
+      const int elit = internal->externalize (ilit);
+      assert (elit);
+      learner->learn (elit);
+    }
+    learner->learn (0);
+  } else
+    LOG ("not exporting learned clause of size %zu", size);
+}
+
+}
diff --git a/hCaD_V2/src/external.hpp b/hCaD_V2/src/external.hpp
new file mode 100644
index 0000000..a7fb452
--- /dev/null
+++ b/hCaD_V2/src/external.hpp
@@ -0,0 +1,356 @@
+#ifndef _external_hpp_INCLUDED
+#define _external_hpp_INCLUDED
+
+/*------------------------------------------------------------------------*/
+
+#include "range.hpp"
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+using namespace std;
+
+/*------------------------------------------------------------------------*/
+
+// The CaDiCaL code is split into three layers:
+//
+//   Solver:       facade object providing the actual API of the solver
+//   External:     communication layer between 'Solver' and 'Internal'
+//   Internal:     the actual solver code
+//
+// Note, that 'Solver' is defined in 'cadical.hpp' and 'solver.cpp', while
+// 'External' and 'Internal' in '{external,internal}.{hpp,cpp}'.
+//
+// Also note, that any user should access the library only through the
+// 'Solver' API.  For the library internal 'Parser' code we make an
+// exception and allow access to both 'External' and 'Internal'.  The former
+// to enforce the same external to internal mapping of variables and the
+// latter for profiling and messages.  The same applies to 'App'.
+//
+// The 'External' class provided here stores the information needed to map
+// external variable indices to internal variables (actually literals).
+// This is helpful for shrinking the working size of the internal solver
+// after many variables become inactive.  It will also help to provide
+// support for extended resolution in the future, since it allows to
+// introduce only internally visible variables (even though we do not know
+// how to support generating incremental proofs in this situation yet).
+//
+// External literals are usually called 'elit' and internal 'ilit'.
+
+/*------------------------------------------------------------------------*/
+
+struct Clause;
+struct Internal;
+struct CubesWithStatus;
+
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+
+struct External {
+
+  /*==== start of state ==================================================*/
+
+  Internal * internal;        // The actual internal solver.
+
+  int max_var;                // External maximum variable index.
+  size_t vsize;               // Allocated external size.
+
+  vector<bool> vals;          // Current external (extended) assignment.
+  vector<int> e2i;            // External 'idx' to internal 'lit'.
+
+  vector<int> assumptions;    // External assumptions.
+
+  // The extension stack for reconstructing complete satisfying assignments
+  // (models) of the original external formula is kept in this external
+  // solver object. It keeps track of blocked clauses and clauses containing
+  // eliminated variable.  These irredundant clauses are stored in terms of
+  // external literals on the 'extension' stack after mapping the
+  // internal literals given as arguments with 'externalize'.
+
+  bool extended;              // Have been extended.
+  vector<int> extension;      // Solution reconstruction extension stack.
+
+  vector<bool> witness;       // Literal witness on extension stack.
+  vector<bool> tainted;       // Literal tainted in adding literals.
+
+  vector<unsigned> frozentab; // Reference counts for frozen variables.
+
+  // Regularly checked terminator if non-zero.  The terminator is set from
+  // 'Solver::set (Terminator *)' and checked by 'Internal::terminating ()'.
+
+  Terminator * terminator;
+
+  // If there is a learner export learned clauses.
+
+  Learner * learner;
+
+  void export_learned_empty_clause ();
+  void export_learned_unit_clause (int ilit);
+  void export_learned_large_clause (const vector<int> &);
+
+  //----------------------------------------------------------------------//
+
+  signed char * solution;     // Given solution checking for debugging.
+  vector<int> original;       // Saved original formula for checking.
+
+  // If 'opts.checkfrozen' is set make sure that only literals are added
+  // which were never completely molten before.  These molten literals are
+  // marked at the beginning of the 'solve' call.  Note that variables
+  // larger than 'max_var' are not molten and can thus always be used in the
+  // future.  Only needed to check and debug old style freeze semantics.
+  //
+  vector<bool> moltentab;
+
+  //----------------------------------------------------------------------//
+
+  const Range vars;           // Provides safe variable iterations.
+
+  /*==== end of state ====================================================*/
+
+  // These two just factor out common sanity (assertion) checking code.
+
+  inline int vidx (int elit) const {
+    assert (elit);
+    assert (elit != INT_MIN);
+    int res = abs (elit);
+    assert (res <= max_var);
+    return res;
+  }
+
+  inline int vlit (int elit) const {
+    assert (elit);
+    assert (elit != INT_MIN);
+    assert (abs (elit) <= max_var);
+    return elit;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  // The following five functions push individual literals or clauses on the
+  // extension stack.  They all take internal literals as argument, and map
+  // them back to external literals first, before pushing them on the stack.
+
+  void push_zero_on_extension_stack ();
+
+  // Our general version of extension stacks always pushes a set of witness
+  // literals (for variable elimination the literal of the eliminated
+  // literal and for blocked clauses the blocking literal) followed by all
+  // the clause literals starting with and separated by zero.
+  //
+  void push_clause_literal_on_extension_stack (int ilit);
+  void push_witness_literal_on_extension_stack (int ilit);
+
+  void push_clause_on_extension_stack (Clause *);
+  void push_clause_on_extension_stack (Clause *, int witness);
+  void push_binary_clause_on_extension_stack (int witness, int other);
+
+  // The main 'extend' function which extends an internal assignment to an
+  // external assignment using the extension stack (and sets 'extended').
+  //
+  void extend ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Marking external literals.
+
+  unsigned elit2ulit (int elit) const {
+    assert (elit);
+    assert (elit != INT_MIN);
+    const int idx = abs (elit) - 1;
+    assert (idx <= max_var);
+    return 2u*idx + (elit < 0);
+  }
+
+  bool marked (const vector<bool> & map, int elit) const {
+    const unsigned ulit = elit2ulit (elit);
+    return ulit < map.size () ? map[ulit] : false;
+  }
+
+  void mark (vector<bool> & map, int elit) {
+    const unsigned ulit = elit2ulit (elit);
+    while (ulit >= map.size ()) map.push_back (false);
+    map[ulit] = true;
+  }
+
+  void unmark (vector<bool> & map, int elit) {
+    const unsigned ulit = elit2ulit (elit);
+    if (ulit < map.size ()) map[ulit] = false;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  void push_external_clause_and_witness_on_extension_stack (
+    const vector<int> & clause, const vector<int> & witness);
+
+  // Restore a clause, which was pushed on the extension stack.
+  void restore_clause (
+    const vector<int>::const_iterator & begin,
+    const vector<int>::const_iterator & end);
+
+  void restore_clauses ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Explicitly freeze and melt literals (instead of just freezing
+  // internally and implicitly assumed literals).  Passes on freezing and
+  // melting to the internal solver, which has separate frozen counters.
+
+  void freeze (int elit);
+  void melt (int elit);
+
+  bool frozen (int elit) {
+    assert (elit);
+    assert (elit != INT_MIN);
+    int eidx = abs (elit);
+    if (eidx > max_var) return false;
+    if (eidx >= (int) frozentab.size ()) return false;
+    return frozentab[eidx] > 0;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  External (Internal *);
+  ~External ();
+
+  void enlarge (int new_max_var);       // Enlarge allocated 'vsize'.
+  void init (int new_max_var);          // Initialize up-to 'new_max_var'.
+
+  int internalize (int);        // Translate external to internal literal.
+
+  /*----------------------------------------------------------------------*/
+
+  // According to the CaDiCaL API contract (as well as IPASIR) we have to
+  // forget about the previous assumptions after a 'solve' call.  This
+  // should however be delayed until we transition out of an 'UNSATISFIED'
+  // state, i.e., after no more 'failed' calls are expected.  Note that
+  // 'failed' requires to know the failing assumptions, and the 'failed'
+  // status of those should cleared before at start of the next 'solve'.
+  // As a consequence 'reset_assumptions' is only called from
+  // 'transition_to_unknown_state' in API calls in 'solver.cpp'.
+
+  void reset_assumptions ();
+
+  // Similarly a valid external assignment obtained through 'extend' has to
+  // be reset at each point it risks to become invalid.  This is done
+  // in the external layer in 'external.cpp' functions..
+
+  void reset_extended ();
+
+  // Finally, the semantics of incremental solving also require that limits
+  // are only valid for the next 'solve' call.  Since the limits can not
+  // really be queried, handling them is less complex and they are just
+  // reset immediately at the end of 'External::solve'.
+
+  void reset_limits ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Proxies to IPASIR functions.
+
+  void add (int elit);
+  void assume (int elit);
+  int solve (bool preprocess_only);
+
+  // We call it 'ival' as abbreviation for 'val' with 'int' return type to
+  // avoid bugs due to using 'signed char tmp = val (lit)', which might turn
+  // a negative value into a positive one (happened in 'extend').
+  //
+  inline int ival (int elit) const {
+    assert (elit != INT_MIN);
+    int eidx = abs (elit), res;
+    if (eidx > max_var) res = -1;
+    else if ((size_t) eidx >= vals.size ()) res = -1;
+    else res = vals[eidx] ? eidx : -eidx;
+    if (elit < 0) res = -res;
+    return res;
+  }
+
+  bool failed (int elit);
+
+  void terminate ();
+
+  // Other important non IPASIR functions.
+
+  int lookahead();
+  CaDiCaL::CubesWithStatus generate_cubes(int, int);
+
+  int fixed (int elit) const;   // Implemented in 'internal.hpp'.
+
+  /*----------------------------------------------------------------------*/
+
+  void phase (int elit);
+  void unphase (int elit);
+
+  /*----------------------------------------------------------------------*/
+
+  // Traversal functions for the witness stack and units.  The explanation
+  // in 'external.cpp' for why we have to distinguish these cases.
+
+  bool traverse_all_frozen_units_as_clauses (ClauseIterator &);
+  bool traverse_all_non_frozen_units_as_witnesses (WitnessIterator &);
+  bool traverse_witnesses_backward (WitnessIterator &);
+  bool traverse_witnesses_forward (WitnessIterator &);
+
+  /*----------------------------------------------------------------------*/
+
+  // Copy flags for determining preprocessing state.
+
+  void copy_flags (External & other) const;
+
+  /*----------------------------------------------------------------------*/
+
+  // Check solver behaves as expected during testing and debugging.
+
+  void check_assumptions_satisfied ();
+  void check_assumptions_failing ();
+
+  void check_solution_on_learned_clause ();
+  void check_solution_on_shrunken_clause (Clause *);
+  void check_solution_on_learned_unit_clause (int unit);
+  void check_no_solution_after_learning_empty_clause ();
+
+  void check_learned_empty_clause () {
+    if (solution) check_no_solution_after_learning_empty_clause ();
+  }
+
+  void check_learned_unit_clause (int unit) {
+    if (solution) check_solution_on_learned_unit_clause (unit);
+  }
+
+  void check_learned_clause () {
+    if (solution) check_solution_on_learned_clause ();
+  }
+
+  void check_shrunken_clause (Clause * c) {
+    if (solution) check_solution_on_shrunken_clause (c);
+  }
+
+  void check_assignment (int (External::*assignment) (int) const);
+
+  void check_satisfiable ();
+  void check_unsatisfiable ();
+
+  void check_solve_result (int res);
+
+  void update_molten_literals ();
+
+  /*----------------------------------------------------------------------*/
+
+  // For debugging and testing only.  See 'solution.hpp' for more details.
+  //
+  inline int sol (int elit) const {
+    assert (solution);
+    assert (elit != INT_MIN);
+    int eidx = abs (elit);
+    if (eidx > max_var) return 0;
+    int res = solution[eidx];
+    if (elit < 0) res = -res;
+    return res;
+  }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/file.cpp b/hCaD_V2/src/file.cpp
new file mode 100644
index 0000000..01b2ec5
--- /dev/null
+++ b/hCaD_V2/src/file.cpp
@@ -0,0 +1,306 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// Some more low-level 'C' headers.
+
+extern "C" {
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+}
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Private constructor.
+
+File::File (Internal *i, bool w, int c, FILE * f, const char * n)
+:
+#ifndef QUIET
+  internal (i),
+#endif
+#if !defined(QUIET) || !defined(NDEBUG)
+  writing (w),
+#endif
+  close_file (c), file (f),
+  _name (n), _lineno (1), _bytes (0)
+{
+  (void) i, (void) w;
+  assert (f), assert (n);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool File::exists (const char * path) {
+  struct stat buf;
+  if (stat (path, &buf)) return false;
+  if (access (path, R_OK)) return false;
+  return true;
+}
+
+bool File::writable (const char * path) {
+  int res;
+  if (!path) res = 1;
+  else if (!strcmp (path, "/dev/null")) res = 0;
+  else {
+    if (!*path) res = 2;
+    else {
+      struct stat buf;
+      const char * p = strrchr (path, '/');
+      if (!p) {
+        if (stat (path, &buf)) res = ((errno == ENOENT) ? 0 : -2);
+        else if (S_ISDIR (buf.st_mode)) res = 3;
+        else res = (access (path, W_OK) ? 4 : 0);
+      } else if (!p[1]) res = 5;
+      else {
+        size_t len = p - path;
+        char * dirname = new char[len + 1];
+        strncpy (dirname, path, len);
+        dirname[len] = 0;
+        if (stat (dirname, &buf)) res = 6;
+        else if (!S_ISDIR (buf.st_mode)) res = 7;
+        else if (access (dirname, W_OK)) res = 8;
+        else if (stat (path, &buf)) res = (errno == ENOENT) ? 0 : -3;
+        else res = access (path, W_OK) ? 9 : 0;
+        delete [] dirname;
+      }
+    }
+  }
+  return !res;
+}
+
+// These are signatures for supported compressed file types.  In 2018 the
+// SAT Competition was running on StarExec and used internally 'bzip2'
+// compressed files, but gave them uncompressed to the solver using exactly
+// the same path (with '.bz2' suffix).  Then 'CaDiCaL' tried to read that
+// actually uncompressed file through 'bzip2', which of course failed.  Now
+// we double check and fall back to reading the file as is, if the signature
+// does not match after issuing a warning.
+
+static int xzsig[] = { 0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00, 0x00, EOF };
+static int bz2sig[] = { 0x42, 0x5A, 0x68, EOF };
+static int gzsig[] = { 0x1F, 0x8B, EOF };
+static int sig7z[] = { 0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C, EOF };
+static int lzmasig[] = { 0x5D, 0x00, 0x00, 0x80, 0x00, EOF };
+
+bool File::match (Internal * internal,
+                  const char * path, const int * sig) {
+  assert (path);
+  FILE * tmp = fopen (path, "r");
+  if (!tmp) {
+    WARNING ("failed to open '%s' to check signature", path);
+    return false;
+  }
+  bool res = true;
+  for (const int *p = sig; res && (*p != EOF); p++)
+    res = (cadical_getc_unlocked (tmp) == *p);
+  fclose (tmp);
+  if (!res) WARNING ("file type signature check for '%s' failed", path);
+  return res;
+}
+
+size_t File::size (const char * path) {
+  struct stat buf;
+  if (stat (path, &buf)) return 0;
+  return (size_t) buf.st_size;
+}
+
+// Check that 'prg' is in the 'PATH' and thus can be found if executed
+// through 'popen'.
+
+char * File::find (const char * prg) {
+  size_t prglen = strlen (prg);
+  const char * c = getenv ("PATH");
+  if (!c) return 0;;
+  size_t len = strlen (c);
+  char * e = new char[len + 1];
+  strcpy (e, c);
+  char * res = 0;
+  for (char * p = e, * q; !res && p < e + len; p = q) {
+    for (q = p; *q && *q != ':'; q++)
+      ;
+    *q++ = 0;
+    size_t pathlen = (q - p) + prglen;
+    char * path = new char [pathlen + 1];
+    sprintf (path, "%s/%s", p, prg);
+    assert (strlen (path) == pathlen);
+    if (exists (path)) res = path;
+    else delete [] path;
+  }
+  delete [] e;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+FILE * File::open_file (Internal * internal, const char * path,
+                                             const char * mode) {
+  (void) internal;
+  return fopen (path, mode);
+}
+
+FILE * File::read_file (Internal * internal, const char * path) {
+  MSG ("opening file to read '%s'", path);
+  return open_file (internal, path, "r");
+}
+
+FILE * File::write_file (Internal * internal, const char * path) {
+  MSG ("opening file to write '%s'", path);
+  return open_file (internal, path, "w");
+}
+
+/*------------------------------------------------------------------------*/
+
+FILE * File::open_pipe (Internal * internal,
+                        const char * fmt, const char * path,
+                        const char * mode) {
+#ifdef QUIET
+  (void) internal;
+#endif
+  size_t prglen = 0;
+  while (fmt[prglen] && fmt[prglen] != ' ') prglen++;
+  char * prg = new char [prglen + 1];
+  strncpy (prg, fmt, prglen);
+  prg[prglen] = 0;
+  char * found = find (prg);
+  if (found) MSG ("found '%s' in path for '%s'", found, prg);
+  if (!found) MSG ("did not find '%s' in path", prg);
+  delete [] prg;
+  if (!found) return 0;
+  delete [] found;
+  char * cmd = new char [strlen (fmt) + strlen (path)];
+  sprintf (cmd, fmt, path);
+  FILE * res = popen (cmd, mode);
+  delete [] cmd;
+  return res;
+}
+
+FILE * File::read_pipe (Internal * internal,
+                        const char * fmt,
+                        const int * sig,
+                        const char * path) {
+  if (!File::exists (path)) {
+    LOG ("file '%s' does not exist", path);
+    return 0;
+  }
+  LOG ("file '%s' exists", path);
+  if (sig && !File::match (internal, path, sig)) return 0;
+  LOG ("file '%s' matches signature for '%s'", path, fmt);
+  MSG ("opening pipe to read '%s'", path);
+  return open_pipe (internal, fmt, path, "r");
+}
+
+FILE * File::write_pipe (Internal * internal,
+                         const char * fmt, const char * path) {
+  MSG ("opening pipe to write '%s'", path);
+  return open_pipe (internal, fmt, path, "w");
+}
+
+/*------------------------------------------------------------------------*/
+
+File * File::read (Internal * internal, FILE * f, const char * n) {
+  return new File (internal, false, 0, f, n);
+}
+
+File * File::write (Internal * internal, FILE * f, const char * n) {
+  return new File (internal, true, 0, f, n);
+}
+
+File * File::read (Internal * internal, const char * path) {
+  FILE * file;
+  int close_input = 2;
+  if (has_suffix (path, ".xz")) {
+    file = read_pipe (internal, "xz -c -d %s", xzsig, path);
+    if (!file) goto READ_FILE;
+  } else if (has_suffix (path, ".lzma")) {
+    file = read_pipe (internal, "lzma -c -d %s", lzmasig, path);
+    if (!file) goto READ_FILE;
+  } else if (has_suffix (path, ".bz2")) {
+    file = read_pipe (internal, "bzip2 -c -d %s", bz2sig, path);
+    if (!file) goto READ_FILE;
+  } else if (has_suffix (path, ".gz")) {
+    file = read_pipe (internal, "gzip -c -d %s", gzsig, path);
+    if (!file) goto READ_FILE;
+  } else if (has_suffix (path, ".7z")) {
+    file = read_pipe (internal, "7z x -so %s 2>/dev/null", sig7z, path);
+    if (!file) goto READ_FILE;
+  } else {
+READ_FILE:
+    file = read_file (internal, path);
+    close_input = 1;
+  }
+
+  return file ? new File (internal, false, close_input, file, path) : 0;
+}
+
+File * File::write (Internal * internal, const char * path) {
+  FILE * file;
+  int close_input = 2;
+  if (has_suffix (path, ".xz"))
+    file = write_pipe (internal, "xz -c > %s", path);
+  else if (has_suffix (path, ".bz2"))
+    file = write_pipe (internal, "bzip2 -c > %s", path);
+  else if (has_suffix (path, ".gz"))
+    file = write_pipe (internal, "gzip -c > %s", path);
+  else if (has_suffix (path, ".7z"))
+    file = write_pipe (internal,
+                       "7z a -an -txz -si -so > %s 2>/dev/null", path);
+  else
+    file = write_file (internal, path), close_input = 1;
+
+  return file ? new File (internal, true, close_input, file, path) : 0;
+}
+
+void File::close () {
+  assert (file);
+  if (close_file == 0) {
+    MSG ("disconnecting from '%s'", name ());
+  }
+  if (close_file == 1) {
+    MSG ("closing file '%s'", name ());
+    fclose (file);
+  }
+  if (close_file == 2) {
+    MSG ("closing pipe command on '%s'", name ());
+    pclose (file);
+  }
+
+  file = 0;     // mark as closed
+
+#ifndef QUIET
+  if (internal->opts.verbose > 1) return;
+  double mb = bytes () / (double) (1 << 20);
+  if (writing)
+    MSG ("after writing %" PRIu64 " bytes %.1f MB", bytes (), mb);
+  else
+    MSG ("after reading %" PRIu64 " bytes %.1f MB", bytes (), mb);
+  if (close_file == 2) {
+    int64_t s = size (name ());
+    double mb = s / (double) (1<<20);
+    if (writing)
+      MSG ("deflated to %" PRId64 " bytes %.1f MB by factor %.2f "
+        "(%.2f%% compression)",
+        s, mb, relative (bytes (), s), percent (bytes () - s, bytes ()));
+    else
+      MSG ("inflated from %" PRId64 " bytes %.1f MB by factor %.2f "
+        "(%.2f%% compression)",
+        s, mb, relative (bytes (), s), percent (bytes () - s, bytes ()));
+  }
+#endif
+}
+
+void File::flush () {
+  assert (file);
+  fflush (file);
+}
+
+File::~File () { if (file) close (); }
+
+}
diff --git a/hCaD_V2/src/file.hpp b/hCaD_V2/src/file.hpp
new file mode 100644
index 0000000..8fef7f1
--- /dev/null
+++ b/hCaD_V2/src/file.hpp
@@ -0,0 +1,177 @@
+#ifndef _file_hpp_INCLUDED
+#define _file_hpp_INCLUDED
+
+#include <cstdio>
+#include <cassert>
+#include <cstdlib>
+
+#ifndef NDEBUG
+#include <climits>
+#endif
+
+/*------------------------------------------------------------------------*/
+#ifndef NUNLOCKED
+#define cadical_putc_unlocked putc_unlocked
+#define cadical_getc_unlocked getc_unlocked
+#else
+#define cadical_putc_unlocked putc
+#define cadical_getc_unlocked getc
+#endif
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+// Wraps a 'C' file 'FILE' with name and supports zipped reading and writing
+// through 'popen' using external helper tools.  Reading has line numbers.
+// Compression and decompression relies on external utilities, e.g., 'gzip',
+// 'bzip2', 'xz', and '7z', which should be in the 'PATH'.
+
+struct Internal;
+
+class File {
+
+#ifndef QUIET
+  Internal * internal;
+#endif
+#if !defined(QUIET) || !defined(NDEBUG)
+  bool writing;
+#endif
+
+  int close_file;       // need to close file (1=fclose, 2=pclose)
+  FILE * file;
+  const char * _name;
+  uint64_t _lineno;
+  uint64_t _bytes;
+
+  File (Internal *, bool, int, FILE *, const char *);
+
+  static FILE * open_file (Internal *,
+                           const char * path, const char * mode);
+  static FILE * read_file (Internal *, const char * path);
+  static FILE * write_file (Internal *, const char * path);
+
+  static FILE * open_pipe (Internal *,
+                           const char * fmt,
+                           const char * path,
+                           const char * mode);
+  static FILE * read_pipe (Internal *,
+                           const char * fmt,
+                           const int * sig,
+                           const char * path);
+  static FILE * write_pipe (Internal *,
+                            const char * fmt, const char * path);
+public:
+
+  static char* find (const char * prg);    // search in 'PATH'
+  static bool exists (const char * path);  // file exists?
+  static bool writable (const char * path);// can write to that file?
+  static size_t size (const char * path);  // file size in bytes
+
+  // Does the file match the file type signature.
+  //
+  static bool match (Internal *, const char * path, const int * sig);
+
+  // Read from existing file. Assume given name.
+  //
+  static File * read (Internal *, FILE * f, const char * name);
+
+  // Open file from path name for reading (possibly through opening a pipe
+  // to a decompression utility, based on the suffix).
+  //
+  static File * read (Internal *, const char * path);
+
+  // Same for writing as for reading above.
+  //
+  static File * write (Internal *, FILE *, const char * name);
+  static File * write (Internal *, const char * path);
+
+  ~File ();
+
+  // Using the 'unlocked' versions here is way faster but
+  // not thread safe if the same file is used by different
+  // threads, which on the other hand currently is impossible.
+
+  int get () {
+    assert (!writing);
+    int res = cadical_getc_unlocked (file);
+    if (res == '\n') _lineno++;
+    if (res != EOF) _bytes++;
+    return res;
+  }
+
+  bool put (char ch) {
+    assert (writing);
+    if (cadical_putc_unlocked (ch, file) == EOF) return false;
+    _bytes++;
+    return true;
+  }
+
+  bool put (unsigned char ch) {
+    assert (writing);
+    if (cadical_putc_unlocked (ch, file) == EOF) return false;
+    _bytes++;
+    return true;
+  }
+
+  bool put (const char * s) {
+    for (const char * p = s; *p; p++)
+      if (!put (*p)) return false;
+    return true;
+  }
+
+  bool put (int lit) {
+    assert (writing);
+    if (!lit) return put ('0');
+    else if (lit == -2147483648) {
+      assert (lit == INT_MIN);
+      return put ("-2147483648");
+    } else {
+      char buffer[11];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      assert (lit != INT_MIN);
+      unsigned idx = abs (lit);
+      while (idx) {
+        assert (i > 0);
+        buffer[--i] = '0' + idx % 10;
+        idx /= 10;
+      }
+      if (lit < 0 && !put ('-')) return false;
+      return put (buffer + i);
+    }
+  }
+
+  bool put (int64_t l) {
+    assert (writing);
+    if (!l) return put ('0');
+    else if (l == INT64_MIN) {
+      assert (sizeof l == 8);
+      return put ("-9223372036854775808");
+    } else {
+      char buffer[21];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      assert (l != INT64_MIN);
+      uint64_t k = l < 0 ? -l : l;
+      while (k) {
+        assert (i > 0);
+        buffer[--i] = '0' + k % 10;
+        k /= 10;
+      }
+      if (l < 0 && !put ('-')) return false;
+      return put (buffer + i);
+    }
+  }
+
+  const char * name () const { return _name; }
+  uint64_t lineno () const { return _lineno; }
+  uint64_t bytes () const { return _bytes; }
+
+  bool closed () { return !file; }
+  void close ();
+  void flush ();
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/flags.cpp b/hCaD_V2/src/flags.cpp
new file mode 100644
index 0000000..cd6cb3d
--- /dev/null
+++ b/hCaD_V2/src/flags.cpp
@@ -0,0 +1,119 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::mark_fixed (int lit) {
+  Flags & f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::FIXED;
+  LOG ("fixed %d", abs (lit));
+  stats.all.fixed++;
+  stats.now.fixed++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.fixed ());
+}
+
+void Internal::mark_eliminated (int lit) {
+  Flags & f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::ELIMINATED;
+  LOG ("eliminated %d", abs (lit));
+  stats.all.eliminated++;
+  stats.now.eliminated++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.eliminated ());
+}
+
+void Internal::mark_pure (int lit) {
+  Flags & f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::PURE;
+  LOG ("pure %d", abs (lit));
+  stats.all.pure++;
+  stats.now.pure++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.pure ());
+}
+
+void Internal::mark_substituted (int lit) {
+  Flags & f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::SUBSTITUTED;
+  LOG ("substituted %d", abs (lit));
+  stats.all.substituted++;
+  stats.now.substituted++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.substituted ());
+}
+
+void Internal::mark_active (int lit) {
+  Flags & f = flags (lit);
+  assert (f.status == Flags::UNUSED);
+  f.status = Flags::ACTIVE;
+  LOG ("activate %d previously unused", abs (lit));
+  assert (stats.inactive);
+  stats.inactive--;
+  assert (stats.unused);
+  stats.unused--;
+  stats.active++;
+  assert (active (lit));
+}
+
+void Internal::reactivate (int lit) {
+  assert (!active (lit));
+  Flags & f = flags (lit);
+  assert (f.status != Flags::FIXED);
+  assert (f.status != Flags::UNUSED);
+#ifdef LOGGING
+  const char * msg = 0;
+#endif
+  switch (f.status) {
+    default:
+    case Flags::ELIMINATED:
+      assert (f.status == Flags::ELIMINATED);
+      assert (stats.now.eliminated > 0);
+      stats.now.eliminated--;
+#ifdef LOGGING
+      msg = "eliminated";
+#endif
+      break;
+    case Flags::SUBSTITUTED:
+#ifdef LOGGING
+      msg = "substituted";
+#endif
+      assert (stats.now.substituted > 0);
+      stats.now.substituted--;
+      break;
+    case Flags::PURE:
+#ifdef LOGGING
+      msg = "pure literal";
+#endif
+      assert (stats.now.pure > 0);
+      stats.now.pure--;
+      break;
+  }
+#ifdef LOGGING
+  assert (msg);
+  LOG ("reactivate previously %s %d", msg, abs (lit));
+#endif
+  f.status = Flags::ACTIVE;
+  assert (active (lit));
+  stats.reactivated++;
+  assert (stats.inactive > 0);
+  stats.inactive--;
+  stats.active++;
+}
+
+}
diff --git a/hCaD_V2/src/flags.hpp b/hCaD_V2/src/flags.hpp
new file mode 100644
index 0000000..3c86892
--- /dev/null
+++ b/hCaD_V2/src/flags.hpp
@@ -0,0 +1,76 @@
+#ifndef _flags_hpp_INCLUDED
+#define _flags_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Flags {        // Variable flags.
+
+  //  The first set of flags is related to 'analyze' and 'minimize'.
+  //
+  bool seen      : 1; // seen in generating first UIP clause in 'analyze'
+  bool keep      : 1; // keep in learned clause in 'minimize'
+  bool poison    : 1;    // can not be removed in 'minimize'
+  bool removable : 1;    // can be removed in 'minimize'
+  bool shrinkable : 1; // can be removed in 'shrink'
+
+  // These three variable flags are used to schedule clauses in subsumption
+  // ('subsume'), variables in bounded variable elimination ('elim') and in
+  // hyper ternary resolution ('ternary').
+  //
+  bool elim      : 1; // removed since last 'elim' round (*)
+  bool subsume   : 1; // added since last 'subsume' round (*)
+  bool ternary   : 1; // added in ternary clause since last 'ternary' (*)
+
+  // These literal flags are used by blocked clause elimination ('block').
+  //
+  unsigned char block : 2;   // removed since last 'block' round (*)
+  unsigned char skip : 2;    // skip this literal as blocking literal
+
+  // Bits for handling assumptions.
+  //
+  unsigned char assumed : 2;
+  unsigned char failed : 2;
+
+  enum {
+    UNUSED      = 0,
+    ACTIVE      = 1,
+    FIXED       = 2,
+    ELIMINATED  = 3,
+    SUBSTITUTED = 4,
+    PURE        = 5
+  };
+
+  unsigned char status : 3;
+
+  // Initialized explicitly in 'Internal::init' through this function.
+  //
+  Flags () {
+    seen = keep = poison = removable = shrinkable = false;
+    subsume = elim = ternary = true;
+    block = 3u;
+    skip = assumed = failed = 0;
+    status = UNUSED;
+  }
+
+  bool unused () const { return status == UNUSED; }
+  bool active () const { return status == ACTIVE; }
+  bool fixed () const { return status == FIXED; }
+  bool eliminated () const { return status == ELIMINATED; }
+  bool substituted () const { return status == SUBSTITUTED; }
+  bool pure () const { return status == PURE; }
+
+  // The flags marked with '(*)' are copied during 'External::copy_flags',
+  // which in essence means they are reset in the copy if they were clear.
+  // This avoids the effort of fruitless preprocessing the copy.
+
+  void copy (Flags & dst) const {
+    dst.elim = elim;
+    dst.subsume = subsume;
+    dst.ternary = ternary;
+    dst.block = block;
+  }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/format.cpp b/hCaD_V2/src/format.cpp
new file mode 100644
index 0000000..2efdc2e
--- /dev/null
+++ b/hCaD_V2/src/format.cpp
@@ -0,0 +1,81 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Format::enlarge () {
+  char * old = buffer;
+  buffer = new char[size = size ? 2*size : 1];
+  memcpy (buffer, old, count);
+  delete [] old;
+}
+
+inline void Format::push_char (char ch) {
+  if (size == count) enlarge ();
+  buffer[count++] = ch;
+}
+
+void Format::push_string (const char * s) {
+  char ch;
+  while ((ch = *s++)) push_char (ch);
+}
+
+void Format::push_int (int d) {
+  char tmp[12];
+  sprintf (tmp, "%d", d);
+  push_string (tmp);
+}
+
+void Format::push_uint64 (uint64_t u) {
+  char tmp[12];
+  sprintf (tmp, "%" PRIu64, u);
+  push_string (tmp);
+}
+
+static bool
+match_format (const char * & str, const char * pattern)
+{
+  assert (pattern);
+  const char * p = str;
+  const char * q = pattern;
+  while (*q)
+    if (*q++ != *p++)
+      return false;
+  str = p;
+  return true;
+}
+
+const char * Format::add (const char * fmt, va_list & ap) {
+  const char * p = fmt;
+  char ch;
+  while ((ch = *p++)) {
+    if (ch != '%') push_char (ch);
+    else if (*p == 'c') push_char (va_arg (ap, int)), p++;
+    else if (*p == 'd') push_int (va_arg (ap, int)), p++;
+    else if (*p == 's') push_string (va_arg (ap, const char*)), p++;
+    else if (match_format (p, PRIu64))
+      push_uint64 (va_arg (ap, uint64_t));
+    else { push_char ('%'); push_char (*p); break; }  // unsupported
+  }
+  push_char (0);
+  count--;        // thus automatic append in subsequent calls.
+  return buffer;
+}
+
+const char * Format::init (const char * fmt, ...) {
+  count = 0;
+  va_list ap;
+  va_start (ap, fmt);
+  const char * res = add (fmt, ap);
+  va_end (ap);
+  return res;
+}
+
+const char * Format::append (const char * fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  const char * res = add (fmt, ap);
+  va_end (ap);
+  return res;
+}
+
+}
diff --git a/hCaD_V2/src/format.hpp b/hCaD_V2/src/format.hpp
new file mode 100644
index 0000000..d0444e5
--- /dev/null
+++ b/hCaD_V2/src/format.hpp
@@ -0,0 +1,33 @@
+#ifndef _format_hpp_INCLUDED
+#define _format_hpp_INCLUDED
+
+#include <cstdarg>
+
+namespace CaDiCaL {
+
+// This class provides a 'printf' style formatting utility.
+// Only '%c', '%d', '%s' are supported at this point.
+// It is used to capture and save an error message.
+
+class Format {
+  char * buffer;
+  int64_t count, size;
+  void enlarge ();
+  void push_char (char);
+  void push_string (const char *);
+  void push_int (int);
+  void push_uint64 (uint64_t);
+  const char * add (const char * fmt, va_list &);
+public:
+  Format () : buffer (0), count (0), size (0) { }
+  ~Format () { if (buffer) delete [] buffer; }
+  const char * init (const char * fmt, ...)
+                     CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  const char * append (const char * fmt, ...)
+                       CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  operator const char * () const { return count ? buffer : 0; }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/gates.cpp b/hCaD_V2/src/gates.cpp
new file mode 100644
index 0000000..ae63463
--- /dev/null
+++ b/hCaD_V2/src/gates.cpp
@@ -0,0 +1,527 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// As in our original SATeLite published at SAT'05 we are trying to find
+// gates in order to restrict the number of resolutions that need to be
+// tried.  If there is such a gate, we only need to consider resolvents
+// among gate and one non-gate clauses.  Resolvents between definitions will
+// be tautological anyhow and resolvents among non-gates can actually be
+// shown to be redundant too.
+
+/*------------------------------------------------------------------------*/
+
+// The next function returns a non-zero if the clause 'c', which is assumed
+// to contain the literal 'first', after removing falsified literals is a
+// binary clause.  Then the actual second literal is returned.
+
+int
+Internal::second_literal_in_binary_clause (Eliminator & eliminator,
+                                           Clause * c, int first)
+{
+  assert (!c->garbage);
+  int second = 0;
+  for (const auto & lit : *c) {
+    if (lit == first) continue;
+    const signed char tmp = val (lit);
+    if (tmp < 0) continue;
+    if (tmp > 0) {
+      mark_garbage (c);
+      elim_update_removed_clause (eliminator, c);
+      return 0;
+    }
+    if (second) { second = INT_MIN; break; }
+    second = lit;
+  }
+  if (!second) return 0;
+  if (second == INT_MIN) return 0;
+  assert (active (second));
+#ifdef LOGGING
+  if (c->size == 2) LOG (c, "found binary");
+  else LOG (c, "found actual binary %d %d", first, second);
+#endif
+  return second;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Mark all other literals in binary clauses with 'first'.  During this
+// marking we might also detect hyper unary resolvents producing a unit.
+// If such a unit is found we propagate it and return immediately.
+
+void Internal::mark_binary_literals (Eliminator & eliminator, int first) {
+
+  if (unsat) return;
+  if (val (first)) return;
+  if (!eliminator.gates.empty ()) return;
+
+  assert (!marked (first));
+  assert (eliminator.marked.empty ());
+
+  const Occs & os = occs (first);
+  for (const auto & c : os) {
+    if (c->garbage) continue;
+    const int second =
+      second_literal_in_binary_clause (eliminator, c, first);
+    if (!second) continue;
+    const int tmp = marked (second);
+    if (tmp < 0) {
+      LOG ("found binary resolved unit %d", first);
+      assign_unit (first);
+      elim_propagate (eliminator, first);
+      return;
+    }
+    if (tmp > 0) {
+      LOG (c, "duplicated actual binary clause");
+      elim_update_removed_clause (eliminator, c);
+      mark_garbage (c);
+      continue;
+    }
+    eliminator.marked.push_back (second);
+    mark (second);
+    LOG ("marked second literal %d in binary clause %d %d",
+      second, first, second);
+  }
+}
+
+// Unmark all literals saved on the 'marked' stack.
+
+void Internal::unmark_binary_literals (Eliminator & eliminator) {
+  LOG ("unmarking %zd literals", eliminator.marked.size ());
+  for (const auto & lit : eliminator.marked)
+    unmark (lit);
+  eliminator.marked.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find equivalence for 'pivot'.  Requires that all other literals in binary
+// clauses with 'pivot' are marked (through 'mark_binary_literals');
+
+void Internal::find_equivalence (Eliminator & eliminator, int pivot) {
+
+  if (!opts.elimequivs) return;
+
+  assert (opts.elimsubst);
+
+  if (unsat) return;
+  if (val (pivot)) return;
+  if (!eliminator.gates.empty ()) return;
+
+  mark_binary_literals (eliminator, pivot);
+  if (unsat || val (pivot)) goto DONE;
+
+  for (const auto & c : occs (-pivot)) {
+
+    if (c->garbage) continue;
+
+    const int second =
+      second_literal_in_binary_clause (eliminator, c, -pivot);
+    if (!second) continue;
+    const int tmp = marked (second);
+    if (tmp > 0) {
+      LOG ("found binary resolved unit %d", second);
+      assign_unit (second);
+      elim_propagate (eliminator, second);
+      if (val (pivot)) break;
+      if (unsat) break;
+    }
+    if (tmp >= 0) continue;
+
+    LOG ("found equivalence %d = %d", pivot, -second);
+    stats.elimequivs++;
+    stats.elimgates++;
+
+    LOG (c, "first gate clause");
+    assert (!c->gate);
+    c->gate = true;
+    eliminator.gates.push_back (c);
+
+    Clause * d = 0;
+    const Occs & ps = occs (pivot);
+    for (const auto & e : ps) {
+      if (e->garbage) continue;
+      const int other =
+        second_literal_in_binary_clause (eliminator, e, pivot);
+      if (other == -second) { d = e; break; }
+    }
+    assert (d);
+
+    LOG (d, "second gate clause");
+    assert (!d->gate);
+    d->gate = true;
+    eliminator.gates.push_back (d);
+
+    break;
+  }
+
+DONE:
+  unmark_binary_literals (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and gates for 'pivot' with a long clause, in which the pivot occurs
+// positively.  Requires that all other literals in binary clauses with
+// 'pivot' are marked (through 'mark_binary_literals');
+
+void Internal::find_and_gate (Eliminator & eliminator, int pivot) {
+
+  if (!opts.elimands) return;
+
+  assert (opts.elimsubst);
+
+  if (unsat) return;
+  if (val (pivot)) return;
+  if (!eliminator.gates.empty ()) return;
+
+  mark_binary_literals (eliminator, pivot);
+  if (unsat || val (pivot)) goto DONE;
+
+  for (const auto & c : occs (-pivot)) {
+
+    if (c->garbage) continue;
+    if (c->size < 3) continue;
+
+    bool all_literals_marked = true;
+    unsigned arity = 0;
+    for (const auto & lit : *c) {
+      if (lit == -pivot) continue;
+      assert (lit != pivot);
+      signed char tmp = val (lit);
+      if (tmp < 0) continue;
+      assert (!tmp);
+      tmp = marked (lit);
+      if (tmp < 0) { arity++; continue; }
+      all_literals_marked = false;
+      break;
+    }
+
+    if (!all_literals_marked) continue;
+
+#ifdef LOGGING
+    if (opts.log) {
+      Logger::print_log_prefix (this);
+      tout.magenta ();
+      printf ("found arity %u AND gate %d = ", arity, -pivot);
+      bool first = true;
+      for (const auto & lit : *c) {
+        if (lit == -pivot) continue;
+        assert (lit != pivot);
+        if (!first) fputs (" & ", stdout);
+        printf ("%d", -lit);
+        first = false;
+      }
+      fputc ('\n', stdout);
+      tout.normal ();
+      fflush (stdout);
+    }
+#endif
+    stats.elimands++;
+    stats.elimgates++;
+
+    (void) arity;
+    assert (!c->gate);
+    c->gate = true;
+    eliminator.gates.push_back (c);
+    for (const auto & lit : *c) {
+      if (lit == -pivot) continue;
+      assert (lit != pivot);
+      signed char tmp = val (lit);
+      if (tmp < 0) continue;
+      assert (!tmp);
+      assert (marked (lit) < 0);
+      marks [vidx (lit)] *= 2;
+    }
+
+    unsigned count = 0;
+    for (const auto & d : occs (pivot)) {
+      if (d->garbage) continue;
+      const int other =
+        second_literal_in_binary_clause (eliminator, d, pivot);
+      if (!other) continue;
+      const int tmp = marked (other);
+      if (tmp != 2) continue;
+      LOG (d, "AND gate binary side clause");
+      assert (!d->gate);
+      d->gate = true;
+      eliminator.gates.push_back (d);
+      count++;
+    }
+    assert (count >= arity);
+    (void) count;
+
+    break;
+  }
+
+DONE:
+  unmark_binary_literals (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and extract ternary clauses.
+
+bool Internal::get_ternary_clause (Clause * d, int & a, int & b, int & c)
+{
+  if (d->garbage) return false;
+  if (d->size < 3) return false;
+  int found = 0;
+  a = b = c = 0;
+  for (const auto & lit : *d) {
+    if (val (lit)) continue;
+       if (++found == 1) a = lit;
+    else if (found == 2) b = lit;
+    else if (found == 3) c = lit;
+    else return false;
+  }
+  return found == 3;
+}
+
+// This function checks whether 'd' exists as ternary clause.
+
+bool Internal::match_ternary_clause (Clause * d, int a, int b, int c) {
+  if (d->garbage) return false;
+  int found = 0;
+  for (const auto & lit : *d) {
+    if (val (lit)) continue;
+    if (a != lit && b != lit && c != lit) return false;
+    found++;
+  }
+  return found == 3;
+}
+
+Clause *
+Internal::find_ternary_clause (int a, int b, int c) {
+  if (occs (b).size () > occs (c).size ()) swap (b, c);
+  if (occs (a).size () > occs (b).size ()) swap (a, b);
+  for (auto d : occs (a))
+    if (match_ternary_clause (d, a, b, c))
+      return d;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find if-then-else gate.
+
+void Internal::find_if_then_else (Eliminator & eliminator, int pivot) {
+
+  if (!opts.elimites) return;
+
+  assert (opts.elimsubst);
+
+  if (unsat) return;
+  if (val (pivot)) return;
+  if (!eliminator.gates.empty ()) return;
+
+  const Occs & os = occs (pivot);
+  const auto end = os.end ();
+  for (auto i = os.begin (); i != end; i++) {
+    Clause * di = *i;
+    int ai, bi, ci;
+    if (!get_ternary_clause (di, ai, bi, ci)) continue;
+    if (bi == pivot) swap (ai, bi);
+    if (ci == pivot) swap (ai, ci);
+    assert (ai == pivot);
+    for (auto j = i + 1; j != end; j++) {
+      Clause * dj = *j;
+      int aj, bj, cj;
+      if (!get_ternary_clause (dj, aj, bj, cj)) continue;
+      if (bj == pivot) swap (aj, bj);
+      if (cj == pivot) swap (aj, cj);
+      assert (aj == pivot);
+      if (abs (bi) == abs (cj)) swap (bj, cj);
+      if (abs (ci) == abs (cj)) continue;
+      if (bi != -bj) continue;
+      Clause * d1 = find_ternary_clause (-pivot, bi, -ci);
+      if (!d1) continue;
+      Clause * d2 = find_ternary_clause (-pivot, bj, -cj);
+      if (!d2) continue;
+      LOG (di, "1st if-then-else");
+      LOG (dj, "2nd if-then-else");
+      LOG (d1, "3rd if-then-else");
+      LOG (d2, "4th if-then-else");
+      LOG ("found ITE gate %d == (%d ? %d : %d)", pivot, -bi, -ci, -cj);
+      assert (!di->gate);
+      assert (!dj->gate);
+      assert (!d1->gate);
+      assert (!d2->gate);
+      di->gate = true;
+      dj->gate = true;
+      d1->gate = true;
+      d2->gate = true;
+      eliminator.gates.push_back (di);
+      eliminator.gates.push_back (dj);
+      eliminator.gates.push_back (d1);
+      eliminator.gates.push_back (d2);
+      stats.elimgates++;
+      stats.elimites++;
+      return;
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and extract clause.
+
+bool Internal::get_clause (Clause * c, vector<int> & l) {
+  if (c->garbage) return false;
+  l.clear ();
+  for (const auto & lit : *c) {
+    if (val (lit)) continue;
+    l.push_back (lit);
+  }
+  return true;
+}
+
+// Check whether 'c' contains only the literals in 'l'.
+
+bool Internal::is_clause (Clause * c, const vector<int> & lits) {
+  if (c->garbage) return false;
+  int size = lits.size ();
+  if (c->size < size) return false;
+  int found = 0;
+  for (const auto & lit : *c) {
+    if (val (lit)) continue;
+    const auto it = find (lits.begin (), lits.end (), lit);
+    if (it == lits.end ()) return false;
+    if (++found > size) return false;
+  }
+  return found == size;
+}
+
+Clause * Internal::find_clause (const vector<int> & lits) {
+  int best = 0;
+  size_t len = 0;
+  for (const auto & lit : lits) {
+    size_t l = occs (lit).size ();
+    if (best && l >= len) continue;
+    len = l, best = lit;
+  }
+  for (auto c : occs (best))
+    if (is_clause (c, lits))
+      return c;
+  return 0;
+}
+
+void Internal::find_xor_gate (Eliminator & eliminator, int pivot) {
+
+  if (!opts.elimxors) return;
+
+  assert (opts.elimsubst);
+
+  if (unsat) return;
+  if (val (pivot)) return;
+  if (!eliminator.gates.empty ()) return;
+
+  vector<int> lits;
+
+  for (auto d : occs (pivot)) {
+
+    if (!get_clause (d, lits)) continue;
+
+    const int size = lits.size ();      // clause size
+    const int arity = size - 1;         // arity of XOR
+
+    if (size < 3) continue;
+    if (arity > opts.elimxorlim) continue;
+
+    assert (eliminator.gates.empty ());
+
+    unsigned needed = (1u << arity) - 1;        // additional clauses
+    unsigned signs = 0;                         // literals to negate
+
+    do {
+      const unsigned prev = signs;
+      while (parity (++signs))
+        ;
+      for (int j = 0; j < size; j++) {
+        const unsigned bit = 1u << j;
+        int lit = lits[j];
+        if ((prev & bit) != (signs & bit))
+          lits[j] = lit = -lit;
+      }
+      Clause * e = find_clause (lits);
+      if (!e) break;
+      eliminator.gates.push_back (e);
+    } while (--needed);
+
+    if (needed) { eliminator.gates.clear (); continue; }
+
+    eliminator.gates.push_back (d);
+    assert (eliminator.gates.size () == (1u << arity));
+
+#ifdef LOGGING
+    if (opts.log) {
+      Logger::print_log_prefix (this);
+      tout.magenta ();
+      printf ("found arity %u XOR gate %d = ", arity, -pivot);
+      bool first = true;
+      for (const auto & lit : *d) {
+        if (lit == pivot) continue;
+        assert (lit != -pivot);
+        if (!first) fputs (" ^ ", stdout);
+        printf ("%d", lit);
+        first = false;
+      }
+      fputc ('\n', stdout);
+      tout.normal ();
+      fflush (stdout);
+    }
+#endif
+    stats.elimgates++;
+    stats.elimxors++;
+    const auto end = eliminator.gates.end ();
+    auto j = eliminator.gates.begin ();
+    for (auto i = j; i != end; i++) {
+      Clause * e = *i;
+      if (e->gate) continue;
+      e->gate = true;
+      LOG (e, "contributing");
+      *j++ = e;
+    }
+    eliminator.gates.resize (j - eliminator.gates.begin ());
+
+    break;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find a gate for 'pivot'.  If such a gate is found, the gate clauses are
+// marked and pushed on the stack of gates.  Further hyper unary resolution
+// might detect units, which are propagated.  This might assign the pivot or
+// even produce the empty clause.
+
+void Internal::find_gate_clauses (Eliminator & eliminator, int pivot)
+{
+  if (!opts.elimsubst) return;
+
+  if (unsat) return;
+  if (val (pivot)) return;
+
+  assert (eliminator.gates.empty ());
+
+  find_equivalence (eliminator, pivot);
+  find_and_gate (eliminator, pivot);
+  find_and_gate (eliminator, -pivot);
+  find_if_then_else (eliminator, pivot);
+  find_xor_gate (eliminator, pivot);
+}
+
+void Internal::unmark_gate_clauses (Eliminator & eliminator) {
+  LOG ("unmarking %zd gate clauses", eliminator.gates.size ());
+  for (const auto & c : eliminator.gates) {
+    assert (c->gate);
+    c->gate = false;
+  }
+  eliminator.gates.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+}
diff --git a/hCaD_V2/src/heap.hpp b/hCaD_V2/src/heap.hpp
new file mode 100644
index 0000000..5e470af
--- /dev/null
+++ b/hCaD_V2/src/heap.hpp
@@ -0,0 +1,198 @@
+#ifndef _heap_hpp_INCLUDED
+#define _heap_hpp_INCLUDED
+
+#include "util.hpp"     // Alphabetically after 'heap.hpp'.
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// This is a priority queue with updates for unsigned integers implemented
+// as binary heap.  We need to map integer elements added (through
+// 'push_back') to positions on the binary heap in 'array'. This map is
+// stored in the 'pos' array. This approach is really wasteful (at least in
+// terms of memory) if only few and a sparse set of integers is added.  So
+// it should not be used in this situation.  A generic priority queue would
+// implement the mapping externally provided by another template parameter.
+// Since we use 'UINT_MAX' as 'not contained' flag, we can only have
+// 'UINT_MAX - 1' elements in the heap.
+
+const unsigned invalid_heap_position = UINT_MAX;
+
+template<class C> class heap {
+
+  vector<unsigned> array; // actual binary heap
+  vector<unsigned> pos;   // positions of elements in array
+  C less;                 // less-than for elements
+
+  // Map an element to its position entry in the 'pos' map.
+  //
+  unsigned & index (unsigned e) {
+    while ((size_t) e >= pos.size ()) pos.push_back (invalid_heap_position);
+    unsigned & res = pos[e];
+    assert (res == invalid_heap_position || (size_t) res < array.size ());
+    return res;
+  }
+
+  bool has_parent (unsigned e) { return index (e) > 0; }
+  bool has_left (unsigned e)   { return (size_t) 2*index (e) + 1 < size (); }
+  bool has_right (unsigned e)  { return (size_t) 2*index (e) + 2 < size (); }
+
+  unsigned parent (unsigned e) {
+    assert(has_parent (e));
+    return array[(index(e)-1)/2];
+  }
+
+  unsigned left (unsigned e) {
+    assert(has_left (e));
+    return array[2*index(e)+1];
+  }
+
+  unsigned right (unsigned e) {
+    assert(has_right (e));
+    return array[2*index(e)+2];
+  }
+
+  // Exchange elements 'a' and 'b' in 'array' and fix their positions.
+  //
+  void exchange (unsigned a, unsigned b) {
+    unsigned & i = index (a), & j = index (b);
+    swap (array[i], array[j]);
+    swap (i, j);
+  }
+
+  // Bubble up an element as far as necessary.
+  //
+  void up (unsigned e) {
+    unsigned p;
+    while (has_parent (e) && less ((p = parent (e)), e))
+      exchange (p, e);
+  }
+
+  // Bubble down an element as far as necessary.
+  //
+  void down (unsigned e) {
+    while (has_left (e)) {
+      unsigned c = left (e);
+      if (has_right (e)) {
+        unsigned r = right (e);
+        if (less (c, r)) c = r;
+      }
+      if (!less (e, c)) break;
+      exchange (e, c);
+    }
+  }
+
+  // Very expensive checker for the main 'heap' invariant.  Can be enabled
+  // to find violations of antisymmetry in the client implementation of
+  // 'less' and as well of course bugs in this heap implementation.  It
+  // should be enabled during testing applications of the heap.
+  //
+  void check () {
+#if 0 // EXPENSIVE HEAP CHECKING IF ENABLED
+#warning "expensive checking in heap enabled"
+    assert (array.size () <= invalid_heap_position);
+    for (size_t i = 0; i < array.size (); i++) {
+      size_t l = 2*i + 1, r = 2*i + 2;
+      if (l < array.size ()) assert (!less (array[i], array[l]));
+      if (r < array.size ()) assert (!less (array[i], array[r]));
+      assert (array[i] >= 0);
+      {
+        assert ((size_t) array[i] < pos.size ());
+        assert (i == (size_t) pos[array[i]]);
+      }
+    }
+    for (size_t i = 0; i < pos.size (); i++) {
+      if (pos[i] == invalid_heap_position) continue;
+      assert (pos[i] < array.size ());
+      assert (array[pos[i]] == (unsigned) i);
+    }
+#endif
+  }
+
+public:
+
+  heap (const C & c) : less (c) { }
+
+  // Number of elements in the heap.
+  //
+  size_t size () const { return array.size (); }
+
+  // Check if no more elements are in the heap.
+  //
+  bool empty () const { return array.empty (); }
+
+  // Check whether 'e' is already in the heap.
+  //
+  bool contains (unsigned e) const {
+    if ((size_t) e >= pos.size ()) return false;
+    return pos[e] != invalid_heap_position;
+  }
+
+  // Add a new (not contained) element 'e' to the heap.
+  //
+  void push_back (unsigned e) {
+    assert (!contains (e));
+    size_t i = array.size ();
+    assert (i < (size_t) invalid_heap_position);
+    array.push_back (e);
+    index (e) = (unsigned) i;
+    up (e);
+    down (e);
+    check ();
+  }
+
+  // Returns the maximum element in the heap.
+  //
+  unsigned front () const { assert (!empty ()); return array[0]; }
+
+  // Removes the maximum element in the heap.
+  //
+  unsigned pop_front () {
+    assert (!empty ());
+    unsigned res = array[0], last = array.back ();
+    if (size () > 1) exchange (res, last);
+    index (res) = invalid_heap_position;
+    array.pop_back ();
+    if (size () > 1) down (last);
+    check ();
+    return res;
+  }
+
+  // Notify the heap, that evaluation of 'less' has changed for 'e'.
+  //
+  void update (unsigned e) {
+    assert (contains (e));
+    up (e);
+    down (e);
+    check ();
+  }
+
+  void clear () {
+    array.clear ();
+    pos.clear ();
+  }
+
+  void erase () {
+    erase_vector (array);
+    erase_vector (pos);
+  }
+
+  void shrink () {
+    shrink_vector (array);
+    shrink_vector (pos);
+  }
+
+  // Standard iterators 'inherited' from 'vector'.
+  //
+  typedef typename vector<unsigned>::iterator iterator;
+  typedef typename vector<unsigned>::const_iterator const_iterator;
+  iterator begin () { return array.begin (); }
+  iterator end () { return array.end (); }
+  const_iterator begin () const { return array.begin (); }
+  const_iterator end () const { return array.end (); }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/instantiate.cpp b/hCaD_V2/src/instantiate.cpp
new file mode 100644
index 0000000..9f3785a
--- /dev/null
+++ b/hCaD_V2/src/instantiate.cpp
@@ -0,0 +1,241 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This provides an implementation of variable instantiation, a technique
+// for removing literals with few occurrence (see also 'instantiate.hpp').
+
+/*------------------------------------------------------------------------*/
+
+// Triggered at the end of a variable elimination round ('elim_round').
+
+void
+Internal::collect_instantiation_candidates (Instantiator & instantiator) {
+  assert (occurring ());
+  for (auto idx : vars) {
+    if (frozen (idx)) continue;
+    if (!active (idx)) continue;
+    if (flags (idx).elim) continue;               // BVE attempt pending
+    for (int sign = -1; sign <= 1; sign += 2) {
+      const int lit = sign * idx;
+      if (noccs (lit) > opts.instantiateocclim) continue;
+      Occs & os = occs (lit);
+      for (const auto & c : os) {
+        if (c->garbage) continue;
+        if (opts.instantiateonce && c->instantiated) continue;
+        if (c->size < opts.instantiateclslim) continue;
+        bool satisfied = false;
+        int unassigned = 0;
+        for (const auto & other : *c) {
+          const signed char tmp = val (other);
+          if (tmp > 0) satisfied = true;
+          if (!tmp) unassigned++;
+        }
+        if (satisfied) continue;
+        if (unassigned < 3) continue;           // avoid learning units
+        size_t negoccs = occs (-lit).size ();
+        LOG (c,
+          "instantiation candidate literal %d "
+          "with %zu negative occurrences in", lit, negoccs);
+        instantiator.candidate (lit, c, c->size, negoccs);
+      }
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Specialized propagation and assignment routines for instantiation.
+
+inline void Internal::inst_assign (int lit) {
+  LOG ("instantiate assign %d", lit);
+  assert (!val (lit));
+  vals[lit] = 1;
+  vals[-lit] = -1;
+  trail.push_back (lit);
+}
+
+bool Internal::inst_propagate () {      // Adapted from 'propagate'.
+  START (propagate);
+  int64_t before = propagated;
+  bool ok = true;
+  while (ok && propagated != trail.size ()) {
+    const int lit = -trail[propagated++];
+    LOG ("instantiate propagating %d", -lit);
+    Watches & ws = watches (lit);
+    const const_watch_iterator eow = ws.end ();
+    const_watch_iterator i = ws.begin ();
+    watch_iterator j = ws.begin ();
+    while (i != eow) {
+      const Watch w = *j++ = *i++;
+      const signed char b = val (w.blit);
+      if (b > 0) continue;
+      if (w.binary ()) {
+        if (b < 0) { ok = false; LOG (w.clause, "conflict"); break; }
+        else inst_assign (w.blit);
+      } else {
+        literal_iterator lits = w.clause->begin ();
+        const int other = lits[0]^lits[1]^lit;
+        lits[0] = other, lits[1] = lit;
+        const signed char u = val (other);
+        if (u > 0) j[-1].blit = other;
+        else {
+          const int size = w.clause->size;
+          const const_literal_iterator end = lits + size;
+          const literal_iterator middle = lits + w.clause->pos;
+          literal_iterator k = middle;
+          signed char v = -1;
+          int r = 0;
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+          if (v < 0) {
+            k = lits + 2;
+            assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+          w.clause->pos = k - lits;
+          assert (lits + 2 <= k), assert (k <= w.clause->end ());
+          if (v > 0) {
+            j[-1].blit = r;
+          } else if (!v) {
+            LOG (w.clause, "unwatch %d in", r);
+            lits[1] = r;
+            *k = lit;
+            watch_literal (r, lit, w.clause);
+            j--;
+          } else if (!u) {
+            assert (v < 0);
+            inst_assign (other);
+          } else {
+            assert (u < 0);
+            assert (v < 0);
+            LOG (w.clause, "conflict");
+            ok = false;
+            break;
+          }
+        }
+      }
+    }
+    if (j != i) {
+      while (i != eow)
+        *j++ = *i++;
+      ws.resize (j - ws.begin ());
+    }
+  }
+  int64_t delta = propagated - before;
+  stats.propagations.instantiate += delta;
+  STOP (propagate);
+  return ok;
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the actual instantiation attempt.
+
+bool Internal::instantiate_candidate (int lit, Clause * c) {
+  stats.instried++;
+  if (c->garbage) return false;
+  assert (!level);
+  bool found = false, satisfied = false, inactive = false;
+  int unassigned = 0;
+  for (const auto & other : *c) {
+    if (other == lit) found = true;
+    const signed char tmp = val (other);
+    if (tmp > 0) { satisfied = true; break; }
+    if (!tmp && !active (other)) { inactive = true; break; }
+    if (!tmp) unassigned++;
+  }
+  if (!found) return false;
+  if (inactive) return false;
+  if (satisfied) return false;
+  if (unassigned < 3) return false;
+  size_t before = trail.size ();
+  assert (propagated == before);
+  assert (active (lit));
+  LOG (c, "trying to instantiate %d in", lit);
+  assert (!c->garbage);
+  c->instantiated = true;
+  level++;
+  inst_assign (lit);                            // Assume 'lit' to true.
+  for (const auto & other : *c) {
+    if (other == lit) continue;
+    const signed char tmp = val (other);
+    if (tmp) { assert (tmp < 0); continue; }
+    inst_assign (-other);                       // Assume other to false.
+  }
+  bool ok = inst_propagate ();                  // Propagate.
+  while (trail.size () > before) {              // Backtrack.
+    const int other = trail.back ();
+    LOG ("instantiate unassign %d", other);
+    trail.pop_back ();
+    assert (val (other) > 0);
+    vals[other] = vals[-other] = 0;
+  }
+  propagated = before;
+  assert (level == 1);
+  level = 0;
+  if (ok) { LOG ("instantiation failed"); return false; }
+  unwatch_clause (c);
+  strengthen_clause (c, lit);
+  watch_clause (c);
+  assert (c->size > 1);
+  LOG ("instantiation succeeded");
+  stats.instantiated++;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to instantiate all candidates collected before through the
+// 'collect_instantiation_candidates' routine.
+
+void Internal::instantiate (Instantiator & instantiator) {
+  assert (opts.instantiate);
+  START (instantiate);
+  stats.instrounds++;
+#ifndef QUIET
+  const int64_t candidates = instantiator.candidates.size ();
+#endif
+  int64_t instantiated = 0, tried = 0;
+  init_watches ();
+  connect_watches ();
+  if (propagated < trail.size ()) {
+    if (!propagate ()) {
+      LOG ("propagation after connecting watches failed");
+      learn_empty_clause ();
+      assert (unsat);
+    }
+  }
+  PHASE ("instantiate", stats.instrounds,
+    "attempting to instantiate %" PRId64 " candidate literal clause pairs",
+    candidates);
+  while (!unsat &&
+         !terminated_asynchronously () &&
+         !instantiator.candidates.empty ()) {
+    Instantiator::Candidate cand = instantiator.candidates.back ();
+    instantiator.candidates.pop_back ();
+    tried++;
+    if (!active (cand.lit)) continue;
+    LOG (cand.clause,
+      "trying to instantiate %d with "
+      "%zd negative occurrences in", cand.lit, cand.negoccs);
+    if (!instantiate_candidate (cand.lit, cand.clause)) continue;
+    instantiated++;
+    VERBOSE (2, "instantiation %" PRId64 " (%.1f%%) succeeded "
+      "(%.1f%%) with %zd negative occurrences in size %d clause",
+      tried, percent (tried, candidates),
+      percent (instantiated, tried), cand.negoccs, cand.size);
+  }
+  PHASE ("instantiate", stats.instrounds,
+    "instantiated %" PRId64 " candidate successfully "
+    "out of %" PRId64 " tried %.1f%%",
+    instantiated, tried, percent (instantiated, tried));
+  report ('I', !instantiated);
+  reset_watches ();
+  STOP (instantiate);
+}
+
+}
diff --git a/hCaD_V2/src/instantiate.hpp b/hCaD_V2/src/instantiate.hpp
new file mode 100644
index 0000000..60ed660
--- /dev/null
+++ b/hCaD_V2/src/instantiate.hpp
@@ -0,0 +1,47 @@
+#ifndef _instantiate_hpp_INCLUDED
+#define _instantiate_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+// We are trying to remove literals in clauses, which occur in few clauses
+// and further restrict this removal to variables for which variable
+// elimination failed.  Thus if for instance we succeed in removing the
+// single occurrence of a literal, pure literal elimination can
+// eliminate the corresponding variable in the next variable elimination
+// round.  The set of such literal clause candidate pairs is collected at
+// the end of a variable elimination round and tried before returning.  The
+// name of this technique is inspired by 'variable instantiation' as
+// described in [AnderssonBjesseCookHanna-DAC'02] and apparently
+// successfully used in the 'Oepir' SAT solver.
+
+struct Clause;
+struct Internal;
+
+class Instantiator {
+
+  friend struct Internal;
+
+  struct Candidate {
+    int lit;
+    int size;
+    size_t negoccs;
+    Clause * clause;
+    Candidate (int l, Clause * c, int s, size_t n) :
+      lit (l), size (s), negoccs (n), clause (c)
+    { }
+  };
+
+  vector<Candidate> candidates;
+
+public:
+
+  void candidate (int l, Clause * c, int s, size_t n) {
+    candidates.push_back (Candidate (l, c, s, n));
+  }
+
+  operator bool () const { return !candidates.empty (); }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/internal.cpp b/hCaD_V2/src/internal.cpp
new file mode 100644
index 0000000..b1e71cf
--- /dev/null
+++ b/hCaD_V2/src/internal.cpp
@@ -0,0 +1,739 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+Internal::Internal ()
+:
+  mode (SEARCH),
+  unsat (false),
+  iterating (false),
+  localsearching (false),
+  lookingahead (false),
+  preprocessing (false),
+  protected_reasons (false),
+  force_saved_phase (false),
+  searching_lucky_phases (false),
+  stable (false),
+  reported (false),
+  rephased (0),
+  vsize (0),
+  max_var (0),
+  level (0),
+  vals (0),
+  score_inc (1.0),
+  pol_sc_inc(1.0),
+  scores (this),
+  conflict (0),
+  ignore (0),
+  propagated (0),
+  propagated2 (0),
+  best_assigned (0),
+  target_assigned (0),
+  no_conflict_until (0),
+  proof (0),
+  checker (0),
+  tracer (0),
+  opts (this),
+#ifndef QUIET
+  profiles (this),
+  force_phase_messages (false),
+#endif
+  arena (this),
+  prefix ("c "),
+  internal (this),
+  external (0),
+  termination_forced (false),
+  vars (this->max_var),
+  lits (this->max_var)
+{
+  control.push_back (Level (0, 0));
+}
+
+Internal::~Internal () {
+  for (const auto & c : clauses)
+    delete_clause (c);
+  if (proof) delete proof;
+  if (tracer) delete tracer;
+  if (checker) delete checker;
+  if (vals) { vals -= vsize; delete [] vals; }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Values in 'vals' can be accessed in the range '[-max_var,max_var]' that
+// is directly by a literal.  This is crucial for performance.  By shifting
+// the start of 'vals' appropriately, we achieve that negative offsets from
+// the start of 'vals' can be used.  We also need to set both values at
+// 'lit' and '-lit' during assignments.  In MiniSAT integer literals are
+// encoded, using the least significant bit as negation.  This avoids taking
+// the 'abs ()' (as in our solution) and thus also avoids a branch in the
+// hot-spot of the solver (clause traversal in propagation).  That solution
+// requires another (branch less) negation of the values though and
+// debugging is harder since literals occur only encoded in clauses.
+// The main draw-back of our solution is that we have to shift the memory
+// and access it through negative indices, which looks less clean (but still
+// as far I can tell is properly defined C / C++).   You might get a warning
+// by static analyzers though.  Clang with '--analyze' thought that this
+// idiom would generate a memory leak thus we use the following dummy.
+
+static signed char * ignore_clang_analyze_memory_leak_warning;
+
+void Internal::enlarge_vals (size_t new_vsize) {
+  signed char * new_vals;
+  const size_t bytes = 2u * new_vsize;
+  new_vals = new signed char [ bytes ]; // g++-4.8 does not like ... { 0 };
+  memset (new_vals, 0, bytes);
+  ignore_clang_analyze_memory_leak_warning = new_vals;
+  new_vals += new_vsize;
+
+  if (vals) memcpy (new_vals - max_var, vals - max_var, 2u*max_var + 1u);
+  vals -= vsize;
+  delete [] vals;
+  vals = new_vals;
+}
+
+/*------------------------------------------------------------------------*/
+
+template<class T>
+static void enlarge_init (vector<T> & v, size_t N, const T & i) {
+  while (v.size () < N)
+    v.push_back (i);
+}
+
+template<class T>
+static void enlarge_only (vector<T> & v, size_t N) {
+  while (v.size () < N)
+    v.push_back (T ());
+}
+
+template<class T>
+static void enlarge_zero (vector<T> & v, size_t N) {
+  enlarge_init (v, N, (const T &) 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::enlarge (int new_max_var) {
+  assert (!level);
+  size_t new_vsize = vsize ? 2*vsize : 1 + (size_t) new_max_var;
+  while (new_vsize <= (size_t) new_max_var) new_vsize *= 2;
+  LOG ("enlarge internal size from %zd to new size %zd", vsize, new_vsize);
+  // Ordered in the size of allocated memory (larger block first).
+  enlarge_only (wtab, 2*new_vsize);
+  enlarge_only (vtab, new_vsize);
+  enlarge_zero (parents, new_vsize);
+  enlarge_only (links, new_vsize);
+  enlarge_zero (btab, new_vsize);
+  enlarge_zero (gtab, new_vsize);
+  enlarge_zero (stab, new_vsize);
+  enlarge_init (ptab, 2*new_vsize, -1);
+  enlarge_only (ftab, new_vsize);
+  enlarge_vals (new_vsize);
+  enlarge_zero (frozentab, new_vsize);
+  const signed char val = opts.phase ? 1 : -1;
+  enlarge_init (phases.saved, new_vsize, val);
+  if(opts.psids) enlarge_zero (phases.act, 2*new_vsize);
+  enlarge_zero (phases.forced, new_vsize);
+  enlarge_zero (phases.target, new_vsize);
+  enlarge_zero (phases.best, new_vsize);
+  enlarge_zero (phases.prev, new_vsize);
+  enlarge_zero (phases.min, new_vsize);
+  enlarge_zero (marks, new_vsize);
+  vsize = new_vsize;
+}
+
+void Internal::init_vars (int new_max_var) {
+  if (new_max_var <= max_var) return;
+  if (level) backtrack ();
+  LOG ("initializing %d internal variables from %d to %d",
+    new_max_var - max_var, max_var + 1, new_max_var);
+  if ((size_t) new_max_var >= vsize) enlarge (new_max_var);
+#ifndef NDEBUG
+  for (int64_t i = -new_max_var; i < -max_var; i++) assert (!vals[i]);
+  for (unsigned i = max_var + 1; i <= (unsigned) new_max_var; i++)
+    assert (!vals[i]), assert (!btab[i]), assert (!gtab[i]);
+  for (uint64_t i = 2*((uint64_t)max_var + 1);
+       i <= 2*(uint64_t)new_max_var + 1;
+       i++)
+    assert (ptab[i] == -1);
+#endif
+  assert (!btab[0]);
+  int old_max_var = max_var;
+  max_var = new_max_var;
+  init_queue (old_max_var, new_max_var);
+  init_scores (old_max_var, new_max_var);
+  int initialized = new_max_var - old_max_var;
+  stats.vars += initialized;
+  stats.unused += initialized;
+  stats.inactive += initialized;
+  LOG ("finished initializing %d internal variables", initialized);
+}
+
+void Internal::add_original_lit (int lit) {
+  assert (abs (lit) <= max_var);
+  if (lit) {
+    original.push_back (lit);
+  } else {
+    if (proof) proof->add_original_clause (original);
+    add_new_original_clause ();
+    original.clear ();
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the main CDCL loop with interleaved inprocessing.
+
+int Internal::cdcl_loop_with_inprocessing () {
+
+  int res = 0;
+
+  START (search);
+
+  if (stable) { START (stable);   report ('['); }
+  else        { START (unstable); report ('{'); }
+
+  while (!res) {
+         if (unsat) res = 20;
+    else if (!propagate ()) analyze ();      // propagate and analyze
+    else if (iterating) iterate ();          // report learned unit
+    else if (satisfied ()) res = 10;         // found model
+    else if (search_limits_hit ()) break;    // decision or conflict limit
+    else if (terminated_asynchronously ())    // externally terminated
+      break;
+    else if (restarting ()) restart ();      // restart by backtracking
+    else if (rephasing ()) rephase ();       // reset variable phases
+    else if (reducing ()) reduce ();         // collect useless clauses
+    else if (probing ()) probe ();           // failed literal probing
+    else if (subsuming ()) subsume ();       // subsumption algorithm
+    else if (eliminating ()) elim ();        // variable elimination
+    else if (compacting ()) compact ();      // collect variables
+    else if (conditioning ()) condition ();  // globally blocked clauses
+    else res = decide ();                    // next decision
+  }
+
+  if (stable) { STOP (stable);   report (']'); }
+  else        { STOP (unstable); report ('}'); }
+
+  STOP (search);
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Most of the limits are only initialized in the first 'solve' call and
+// increased as in a stand-alone non-incremental SAT call except for those
+// explicitly marked as being reset below.
+
+void Internal::init_report_limits () {
+  reported = false;
+  lim.report = 0;
+}
+
+void Internal::init_preprocessing_limits () {
+
+  const bool incremental = lim.initialized;
+  if (incremental)
+    LOG ("reinitializing preprocessing limits incrementally");
+  else LOG ("initializing preprocessing limits and increments");
+
+  const char * mode = 0;
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental) mode = "keeping";
+  else {
+    lim.subsume = stats.conflicts + scale (opts.subsumeint);
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s subsume limit %" PRId64 " after %" PRId64 " conflicts",
+    mode, lim.subsume, lim.subsume - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental) mode = "keeping";
+  else {
+    last.elim.marked = -1;
+    lim.elim = stats.conflicts + scale (opts.elimint);
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s elim limit %" PRId64 " after %" PRId64 " conflicts",
+    mode, lim.elim, lim.elim - stats.conflicts);
+
+  // Initialize and reset elimination bounds in any case.
+
+  lim.elimbound = opts.elimboundmin;
+  LOG ("elimination bound %" PRId64 "", lim.elimbound);
+
+  /*----------------------------------------------------------------------*/
+
+  if (!incremental) {
+
+    last.ternary.marked = -1;   // TODO explain why this is necessary.
+
+    lim.compact = stats.conflicts + opts.compactint;
+    LOG ("initial compact limit %" PRId64 " increment %" PRId64 "",
+      lim.compact, lim.compact - stats.conflicts);
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental) mode = "keeping";
+  else {
+    lim.probe = stats.conflicts + opts.probeint;
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s probe limit %" PRId64 " after %" PRId64 " conflicts",
+    mode, lim.probe, lim.probe - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental) mode = "keeping";
+  else {
+    lim.condition = stats.conflicts + opts.conditionint;
+    mode = "initial";
+  }
+  LOG ("%s condition limit %" PRId64 " increment %" PRId64,
+    mode, lim.condition, lim.condition - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  // Initial preprocessing rounds.
+
+  if (inc.preprocessing <= 0) {
+    lim.preprocessing = 0;
+    LOG ("no preprocessing");
+  } else {
+    lim.preprocessing = inc.preprocessing;
+    LOG ("limiting to %" PRId64 " preprocessing rounds", lim.preprocessing);
+  }
+
+}
+
+void Internal::init_search_limits () {
+
+  const bool incremental = lim.initialized;
+  if (incremental) LOG ("reinitializing search limits incrementally");
+  else LOG ("initializing search limits and increments");
+
+  const char * mode = 0;
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental) mode = "keeping";
+  else {
+    last.reduce.conflicts = -1;
+    lim.reduce = stats.conflicts + opts.reduceint;
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s reduce limit %" PRId64 " after %" PRId64 " conflicts",
+    mode, lim.reduce, lim.reduce - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental) mode = "keeping";
+  else {
+    lim.flush = opts.flushint;
+    inc.flush = opts.flushint;
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s flush limit %" PRId64 " interval %" PRId64 "",
+    mode, lim.flush, inc.flush);
+
+  /*----------------------------------------------------------------------*/
+
+  // Initialize or reset 'rephase' limits in any case.
+
+  lim.rephase = stats.conflicts + opts.rephaseint;
+  lim.rephased[0] = lim.rephased[1] = 0;
+  LOG ("new rephase limit %" PRId64 " after %" PRId64 " conflicts",
+    lim.rephase, lim.rephase - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  // Initialize or reset 'restart' limits in any case.
+
+  lim.restart = stats.conflicts + opts.restartint;
+  LOG ("new restart limit %" PRId64 " increment %" PRId64 "",
+    lim.restart, lim.restart - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  if (!incremental) {
+    stable = opts.stabilize && opts.stabilizeonly;
+    if (stable) LOG ("starting in always forced stable phase");
+    else LOG ("starting in default non-stable phase");
+    init_averages ();
+  } else if (opts.stabilize && opts.stabilizeonly) {
+    LOG ("keeping always forced stable phase");
+    assert (stable);
+  } else if (stable) {
+    LOG ("switching back to default non-stable phase");
+    stable = false;
+    swap_averages ();
+  } else LOG ("keeping non-stable phase");
+
+  inc.stabilize = opts.stabilizeint;
+  lim.stabilize = stats.conflicts + inc.stabilize;
+  LOG ("new stabilize limit %" PRId64 " after %" PRId64 " conflicts",
+    lim.stabilize, inc.stabilize);
+
+  if (opts.stabilize && opts.reluctant) {
+    LOG ("new restart reluctant doubling sequence period %d",
+      opts.reluctant);
+    reluctant.enable (opts.reluctant, opts.reluctantmax);
+  } else reluctant.disable ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Conflict and decision limits.
+
+  if (inc.conflicts < 0) {
+    lim.conflicts = -1;
+    LOG ("no limit on conflicts");
+  } else {
+    lim.conflicts = stats.conflicts + inc.conflicts;
+    LOG ("conflict limit after %" PRId64 " conflicts at %" PRId64 " conflicts",
+      inc.conflicts, lim.conflicts);
+  }
+
+  if (inc.decisions < 0) {
+    lim.decisions = -1;
+    LOG ("no limit on decisions");
+  } else {
+    lim.decisions = stats.decisions + inc.decisions;
+    LOG ("conflict limit after %" PRId64 " decisions at %" PRId64 " decisions",
+      inc.decisions, lim.decisions);
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  // Initial preprocessing rounds.
+
+  if (inc.localsearch <= 0) {
+    lim.localsearch = 0;
+    LOG ("no local search");
+  } else {
+    lim.localsearch = inc.localsearch;
+    LOG ("limiting to %" PRId64 " local search rounds", lim.localsearch);
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  lim.initialized = true;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::preprocess_round (int round) {
+  (void) round;
+  if (unsat) return false;
+  if (!max_var) return false;
+  START (preprocess);
+  struct { int64_t vars, clauses; } before, after;
+  before.vars = active ();
+  before.clauses = stats.current.irredundant;
+  stats.preprocessings++;
+  assert (!preprocessing);
+  preprocessing = true;
+  PHASE ("preprocessing", stats.preprocessings,
+    "starting round %d with %" PRId64 " variables and %" PRId64 " clauses",
+    round, before.vars, before.clauses);
+  int old_elimbound = lim.elimbound;
+  if (opts.probe) probe (false);
+  if (opts.elim) elim (false);
+  if (opts.condition) condition (false);
+  after.vars = active ();
+  after.clauses = stats.current.irredundant;
+  assert (preprocessing);
+  preprocessing = false;
+  PHASE ("preprocessing", stats.preprocessings,
+    "finished round %d with %" PRId64 " variables and %" PRId64 " clauses",
+    round, after.vars, after.clauses);
+  STOP (preprocess);
+  report ('P');
+  if (unsat) return false;
+  if (after.vars < before.vars) return true;
+  if (old_elimbound < lim.elimbound) return true;
+  return false;
+}
+
+int Internal::preprocess () {
+  for (int i = 0; i < lim.preprocessing; i++)
+    if (!preprocess_round (i))
+      break;
+  if (unsat) return 20;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::try_to_satisfy_formula_by_saved_phases () {
+  LOG ("satisfying formula by saved phases");
+  assert (!level);
+  assert (!force_saved_phase);
+  assert (propagated == trail.size ());
+  force_saved_phase = true;
+  int res = 0;
+  while (!res) {
+    if (satisfied ()) {
+      LOG ("formula indeed satisfied by saved phases");
+      res = 10;
+    } else if (decide ()) {
+      LOG ("inconsistent assumptions with redundant clauses and phases");
+      res = 20;
+    } else if (!propagate ()) {
+      LOG ("saved phases do not satisfy redundant clauses");
+      assert (level > 0);
+      backtrack ();
+      conflict = 0;             // ignore conflict
+      assert (!res);
+      break;
+    }
+  }
+  assert (force_saved_phase);
+  force_saved_phase = false;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::produce_failed_assumptions () {
+  LOG ("producing failed assumptions");
+  assert (!level);
+  assert (!assumptions.empty ());
+  while (!unsat) {
+    assert (!satisfied ());
+    if (decide ()) break;
+    while (!unsat && !propagate ())
+      analyze ();
+  }
+  if (unsat) LOG ("formula is actually unsatisfiable unconditionally");
+  else LOG ("assumptions indeed failing");
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::local_search_round (int round) {
+
+  assert (round > 0);
+
+  if (unsat) return false;
+  if (!max_var) return false;
+
+  START_OUTER_WALK ();
+  assert (!localsearching);
+  localsearching = true;
+
+  // Determine propagation limit quadratically scaled with rounds.
+  //
+  int64_t limit = opts.walkmineff;
+  limit *= round;
+  if (LONG_MAX / round > limit) limit *= round;
+  else limit = LONG_MAX;
+
+  int res = walk_round (limit, true);
+
+  assert (localsearching);
+  localsearching = false;
+  STOP_OUTER_WALK ();
+
+  report ('L');
+
+  return res;
+}
+
+int Internal::local_search () {
+
+  if (unsat) return 0;
+  if (!max_var) return 0;
+  if (!opts.walk) return 0;
+
+  int res = 0;
+
+  for (int i = 1; !res && i <= lim.localsearch; i++)
+    res = local_search_round (i);
+
+  if (res == 10) {
+    LOG ("local search determined formula to be satisfiable");
+    assert (!stats.walk.minimum);
+    res = try_to_satisfy_formula_by_saved_phases ();
+  } else if (res == 20) {
+    LOG ("local search determined assumptions to be inconsistent");
+    assert (!assumptions.empty ());
+    produce_failed_assumptions ();
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::solve (bool preprocess_only) {
+  assert (clause.empty ());
+  START (solve);
+  if (preprocess_only) LOG ("internal solving in preprocessing only mode");
+  else LOG ("internal solving in full mode");
+  init_report_limits ();
+  int res = already_solved ();
+  if (!res) res = restore_clauses ();
+  if (!res) {
+    init_preprocessing_limits ();
+    if (!preprocess_only) init_search_limits ();
+  }
+  if (!res) res = preprocess ();
+  if (!preprocess_only) {
+    if (!res) res = local_search ();
+    if (!res) res = lucky_phases ();
+    if (!res) res = cdcl_loop_with_inprocessing ();
+  }
+  reset_solving ();
+  report_solving (res);
+  STOP (solve);
+  return res;
+}
+
+int Internal::already_solved () {
+  int res = 0;
+  if (unsat) {
+    LOG ("already inconsistent");
+    res = 20;
+  } else {
+    if (level) backtrack ();
+    if (!propagate ()) {
+      LOG ("root level propagation produces conflict");
+      learn_empty_clause ();
+      res = 20;
+    }
+    if(max_var == 0 && res == 0)
+      res = 10;
+  }
+  return res;
+}
+void Internal::report_solving (int res) {
+       if (res == 10) report ('1');
+  else if (res == 20) report ('0');
+  else                report ('?');
+}
+
+void Internal::reset_solving () {
+  if (termination_forced) {
+
+    // TODO this leads potentially to a data race if the external
+    // user is calling 'terminate' twice within one 'solve' call.
+    // A proper solution would be to guard / protect setting the
+    // 'termination_forced' flag and only allow it during solving and
+    // ignore it otherwise thus also the second time it is called during a
+    // 'solve' call.  We could move resetting it also the start of
+    // 'solve'.
+    //
+    termination_forced = false;
+
+    LOG ("reset forced termination");
+  }
+}
+
+int Internal::restore_clauses () {
+  int res = 0;
+  if (opts.restoreall <= 1 &&
+      external->tainted.empty ()) {
+    LOG ("no tainted literals and nothing to restore");
+    report ('*');
+  } else {
+    report ('+');
+    external->restore_clauses ();
+    internal->report ('r');
+    if (!unsat && !propagate ()) {
+      LOG ("root level propagation after restore produces conflict");
+      learn_empty_clause ();
+      res = 20;
+    }
+  }
+  return res;
+}
+
+int Internal::lookahead () {
+  assert (clause.empty ());
+  START (lookahead);
+  assert (!lookingahead);
+  lookingahead = true;
+  int tmp = already_solved ();
+  if (!tmp) tmp = restore_clauses ();
+  int res = 0;
+  if (!tmp) res = lookahead_probing ();
+  if (res == INT_MIN) res = 0;
+  reset_solving ();
+  report_solving (tmp);
+  assert (lookingahead);
+  lookingahead = false;
+  STOP(lookahead);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::print_statistics () {
+  stats.print (this);
+  if (checker) checker->print_stats ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Only useful for debugging purposes.
+
+void Internal::dump (Clause * c) {
+  for (const auto & lit : *c)
+    printf ("%d ", lit);
+  printf ("0\n");
+}
+
+void Internal::dump () {
+  int64_t m = assumptions.size ();
+  for (auto idx : vars)
+    if (fixed (idx)) m++;
+  for (const auto & c : clauses)
+    if (!c->garbage) m++;
+  printf ("p cnf %d %" PRId64 "\n", max_var, m);
+  for (auto idx : vars) {
+    const int tmp = fixed (idx);
+    if (tmp) printf ("%d 0\n", tmp < 0 ? -idx : idx);
+  }
+  for (const auto & c : clauses)
+    if (!c->garbage) dump (c);
+  for (const auto & lit : assumptions)
+    printf ("%d 0\n", lit);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::traverse_clauses (ClauseIterator & it) {
+  vector<int> eclause;
+  if (unsat) return it.clause (eclause);
+  for (const auto & c : clauses) {
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+    bool satisfied = false;
+    for (const auto & ilit : *c) {
+      const int tmp = fixed (ilit);
+      if (tmp > 0) { satisfied = true; break; }
+      if (tmp < 0) continue;
+      const int elit = externalize (ilit);
+      eclause.push_back (elit);
+    }
+    if (!satisfied && !it.clause (eclause))
+      return false;
+    eclause.clear ();
+  }
+  return true;
+}
+
+}
diff --git a/hCaD_V2/src/internal.hpp b/hCaD_V2/src/internal.hpp
new file mode 100644
index 0000000..8d8ebbc
--- /dev/null
+++ b/hCaD_V2/src/internal.hpp
@@ -0,0 +1,1351 @@
+#ifndef _internal_hpp_INCLUDED
+#define _internal_hpp_INCLUDED
+
+/*------------------------------------------------------------------------*/
+
+// Common 'C' headers.
+
+#include <cassert>
+#include <climits>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cctype>
+#include <csignal>
+#include <cinttypes>
+
+// Less common 'C' header.
+
+extern "C" {
+#include <unistd.h>
+}
+
+/*------------------------------------------------------------------------*/
+
+// Common 'C++' headers.
+
+#include <algorithm>
+#include <queue>
+#include <string>
+#include <vector>
+
+/*------------------------------------------------------------------------*/
+
+// All internal headers are included here.  This gives a nice overview on
+// what is needed altogether. The 'Internal' class needs almost all the
+// headers anyhow (since the idea is to avoid pointer references as much as
+// possible).  Most implementation files need to see the definition of the
+// 'Internal' too.  Thus there is no real advantage in trying to reduce the
+// number of header files included here.  The other benefit of having all
+// header files here is that '.cpp' files then only need to include this.
+
+#include "arena.hpp"
+#include "averages.hpp"
+#include "bins.hpp"
+#include "block.hpp"
+#include "cadical.hpp"
+#include "checker.hpp"
+#include "clause.hpp"
+#include "config.hpp"
+#include "contract.hpp"
+#include "cover.hpp"
+#include "elim.hpp"
+#include "ema.hpp"
+#include "external.hpp"
+#include "file.hpp"
+#include "flags.hpp"
+#include "format.hpp"
+#include "heap.hpp"
+#include "instantiate.hpp"
+#include "internal.hpp"
+#include "level.hpp"
+#include "limit.hpp"
+#include "logging.hpp"
+#include "message.hpp"
+#include "observer.hpp"
+#include "occs.hpp"
+#include "options.hpp"
+#include "parse.hpp"
+#include "phases.hpp"
+#include "profile.hpp"
+#include "proof.hpp"
+#include "queue.hpp"
+#include "radix.hpp"
+#include "random.hpp"
+#include "range.hpp"
+#include "reluctant.hpp"
+#include "resources.hpp"
+#include "score.hpp"
+#include "stats.hpp"
+#include "terminal.hpp"
+#include "tracer.hpp"
+#include "util.hpp"
+#include "var.hpp"
+#include "version.hpp"
+#include "vivify.hpp"
+#include "watch.hpp"
+#include "reap.hpp"
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+using namespace std;
+
+struct Coveror;
+struct External;
+struct Walker;
+
+struct CubesWithStatus {
+  int status;
+  std::vector<std::vector<int>> cubes;
+};
+
+/*------------------------------------------------------------------------*/
+
+struct Internal {
+
+  /*----------------------------------------------------------------------*/
+
+  // The actual internal state of the solver is set and maintained in this
+  // section.  This is currently only used for debugging and testing.
+
+  enum Mode {
+    BLOCK    = (1<<0),
+    CONDITION= (1<<1),
+    COVER    = (1<<2),
+    DECOMP   = (1<<3),
+    DEDUP    = (1<<4),
+    ELIM     = (1<<5),
+    LUCKY    = (1<<6),
+    PROBE    = (1<<7),
+    SEARCH   = (1<<8),
+    SIMPLIFY = (1<<9),
+    SUBSUME  = (1<<10),
+    TERNARY  = (1<<11),
+    TRANSRED = (1<<12),
+    VIVIFY   = (1<<13),
+    WALK     = (1<<14),
+  };
+
+  bool in_mode (Mode m) const { return (mode & m) != 0; }
+  void set_mode (Mode m) { assert (!(mode & m)); mode |= m; }
+  void reset_mode (Mode m) { assert (mode & m); mode &= ~m; }
+  void require_mode (Mode m) const { assert (mode & m), (void) m; }
+
+  /*----------------------------------------------------------------------*/
+
+  int mode;                     // current internal state
+  bool unsat;                   // empty clause found or learned
+  bool iterating;               // report learned unit ('i' line)
+  bool localsearching;          // true during local search
+  bool lookingahead;            // true during look ahead
+  bool preprocessing;           // true during preprocessing
+  bool protected_reasons;       // referenced reasons are protected
+  bool force_saved_phase;       // force saved phase in decision
+  bool searching_lucky_phases;  // during 'lucky_phases'
+  bool stable;                  // true during stabilization phase
+  bool reported;                // reported in this solving call
+  char rephased;                // last type of resetting phases
+  Reluctant reluctant;          // restart counter in stable mode
+  size_t vsize;                 // actually allocated variable data size
+  int max_var;                  // internal maximum variable index
+  int level;                    // decision level ('control.size () - 1')
+  Phases phases;                // saved, target and best phases
+  signed char * vals;           // assignment [-max_var,max_var]
+  vector<signed char> marks;    // signed marks [1,max_var]
+  vector<unsigned> frozentab;   // frozen counters [1,max_var]
+  vector<int> i2e;              // maps internal 'idx' to external 'lit'
+  Queue queue;                  // variable move to front decision queue
+  Links links;                  // table of links for decision queue
+  double pol_sc_inc;          // current polarity score increment for PSIDS heuristic
+  double score_inc;             // current score increment
+  ScoreSchedule scores;         // score based decision priority queue
+  vector<double> stab;          // table of variable scores [1,max_var]
+  vector<Var> vtab;             // variable table [1,max_var]
+  vector<int> parents;          // parent literals during probing
+  vector<Flags> ftab;           // variable and literal flags
+  vector<int64_t> btab;         // enqueue time stamps for queue
+  vector<int64_t> gtab;         // time stamp table to recompute glue
+  vector<Occs> otab;            // table of occurrences for all literals
+  vector<int> ptab;             // table for caching probing attempts
+  vector<int64_t> ntab;         // number of one-sided occurrences table
+  vector<Bins> big;             // binary implication graph
+  vector<Watches> wtab;         // table of watches for all literals
+  Clause * conflict;            // set in 'propagation', reset in 'analyze'
+  Clause * ignore;              // ignored during 'vivify_propagate'
+  size_t propagated;            // next trail position to propagate
+  size_t propagated2;           // next binary trail position to propagate
+  size_t best_assigned;         // best maximum assigned ever
+  size_t target_assigned;       // maximum assigned without conflict
+  size_t no_conflict_until;     // largest trail prefix without conflict
+  vector<int> trail;            // currently assigned literals
+  vector<int> clause;           // simplified in parsing & learning
+  vector<int> assumptions;      // assumed literals
+  vector<int> original;         // original added literals
+  vector<int> levels;           // decision levels in learned clause
+  vector<int> analyzed;         // analyzed literals in 'analyze'
+  vector<int> minimized;        // removable or poison in 'minimize'
+  vector<int> shrinkable;       // removable or poison in 'shrink'
+  Reap reap;                    // radix heap for shrink
+
+  vector<int> probes;           // remaining scheduled probes
+  vector<Level> control;        // 'level + 1 == control.size ()'
+  vector<Clause*> clauses;      // ordered collection of all clauses
+  Averages averages;            // glue, size, jump moving averages
+  Limit lim;                    // limits for various phases
+  Last last;                    // statistics at last occurrence
+  Inc inc;                      // increments on limits
+  Proof * proof;                // clausal proof observers if non zero
+  Checker * checker;            // online proof checker observing proof
+  Tracer * tracer;              // proof to file tracer observing proof
+  Options opts;                 // run-time options
+  Stats stats;                  // statistics
+#ifndef QUIET
+  Profiles profiles;            // time profiles for various functions
+  bool force_phase_messages;    // force 'phase (...)' messages
+#endif
+  Arena arena;                  // memory arena for moving garbage collector
+  Format error_message;         // provide persistent error message
+  string prefix;                // verbose messages prefix
+
+  Internal * internal;          // proxy to 'this' in macros
+  External * external;          // proxy to 'external' buddy in 'Solver'
+
+  /*----------------------------------------------------------------------*/
+
+  // Asynchronous termination flag written by 'terminate' and read by
+  // 'terminated_asynchronously' (the latter at the end of this header).
+  //
+  volatile bool termination_forced;
+
+  /*----------------------------------------------------------------------*/
+
+  const Range vars;             // Provides safe variable iteration.
+  const Sange lits;             // Provides safe literal iteration.
+
+  /*----------------------------------------------------------------------*/
+
+  Internal ();
+  ~Internal ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Internal delegates and helpers for corresponding functions in
+  // 'External' and 'Solver'.  The 'init_vars' function initializes
+  // variables up to and including the requested variable index.
+  //
+  void init_vars (int new_max_var);
+
+  void init_enqueue (int idx);
+  void init_queue (int old_max_var, int new_max_var);
+
+  void init_scores (int old_max_var, int new_max_var);
+
+  void add_original_lit (int lit);
+
+  // Enlarge tables.
+  //
+  void enlarge_vals (size_t new_vsize);
+  void enlarge (int new_max_var);
+
+  // A variable is 'active' if it is not eliminated nor fixed.
+  //
+  bool active (int lit) { return flags(lit).active (); }
+
+  int active () const {
+    int res = stats.active;
+#ifndef NDEBUG
+    int tmp = max_var;
+    tmp -= stats.unused;
+    tmp -= stats.now.fixed;
+    tmp -= stats.now.eliminated;
+    tmp -= stats.now.substituted;
+    tmp -= stats.now.pure;
+    assert (tmp >= 0);
+    assert (tmp == res);
+#endif
+    return res;
+  }
+
+  void reactivate (int lit);    // During 'restore'.
+
+  // Currently remaining active redundant and irredundant clauses.
+
+  int64_t redundant () const { return stats.current.redundant; }
+
+  int64_t irredundant () const { return stats.current.irredundant; }
+
+  double clause_variable_ratio () const {
+    return relative (irredundant (), active ());
+  }
+
+  // Scale values relative to clause variable ratio.
+  //
+  double scale (double v) const;
+
+  // Unsigned literals (abs) with checks.
+  //
+  int vidx (int lit) const {
+    int idx;
+    assert (lit);
+    assert (lit != INT_MIN);
+    idx = abs (lit);
+    assert (idx <= max_var);
+    return idx;
+  }
+
+  // Unsigned version with LSB denoting sign.  This is used in indexing arrays
+  // by literals.  The idea is to keep the elements in such an array for both
+  // the positive and negated version of a literal close together.
+  //
+  unsigned vlit (int lit) { return (lit < 0) + 2u * (unsigned) vidx (lit); }
+
+  int u2i (unsigned u) {
+    assert (u > 1);
+    int res = u/2;
+    assert (res <= max_var);
+    if (u & 1) res = -res;
+    return res;
+  }
+
+  // Helper functions to access variable and literal data.
+  //
+  Var & var (int lit)        { return vtab[vidx (lit)]; }
+  Link & link (int lit)      { return links[vidx (lit)]; }
+  Flags & flags (int lit)    { return ftab[vidx (lit)]; }
+  int64_t & bumped (int lit) { return btab[vidx (lit)]; }
+  int & propfixed (int lit)  { return ptab[vlit (lit)]; }
+  double & score (int lit)   { return stab[vidx (lit)]; }
+
+  const Flags &
+  flags (int lit) const       { return ftab[vidx (lit)]; }
+
+  bool occurring () const     { return !otab.empty (); }
+  bool watching () const      { return !wtab.empty (); }
+
+  Bins & bins (int lit)       { return big[vlit (lit)]; }
+  Occs & occs (int lit)       { return otab[vlit (lit)]; }
+  int64_t & noccs (int lit)   { return ntab[vlit (lit)]; }
+  Watches & watches (int lit) { return wtab[vlit (lit)]; }
+
+  // Variable bumping through exponential VSIDS (EVSIDS) as in MiniSAT.
+  //
+  bool use_scores () const { return opts.score && stable; }
+  void bump_variable_score (int lit);
+  void bump_variable_score_inc ();
+  void rescale_variable_scores ();
+
+  void pol_dec_act ();
+  void rescale_pol_scs ();
+  void bump_pol_sc (int l);
+  // Marking variables with a sign (positive or negative).
+  //
+  signed char marked (int lit) const {
+    signed char res = marks [ vidx (lit) ];
+    if (lit < 0) res = -res;
+    return res;
+  }
+  void mark (int lit) {
+    assert (!marked (lit));
+    marks[vidx (lit)] = sign (lit);
+    assert (marked (lit) > 0);
+    assert (marked (-lit) < 0);
+  }
+  void unmark (int lit) {
+    marks [ vidx (lit) ] = 0;
+    assert (!marked (lit));
+  }
+
+  // Use only bits 6 and 7 to store the sign or zero.  The remaining
+  // bits can be use as additional flags.
+  //
+  signed char marked67 (int lit) const {
+    signed char res = marks [ vidx (lit) ] >> 6;
+    if (lit < 0) res = -res;
+    return res;
+  }
+  void mark67 (int lit) {
+    signed char & m = marks[vidx (lit)];
+    const signed char mask = 0x3f;
+#ifndef NDEBUG
+    const signed char bits = m & mask;
+#endif
+    m = (m & mask) | (sign (lit) << 6);
+    assert (marked (lit) > 0);
+    assert (marked (-lit) < 0);
+    assert ((m & mask) == bits);
+    assert (marked67 (lit) > 0);
+    assert (marked67 (-lit) < 0);
+  }
+  void unmark67 (int lit) {
+    signed char & m = marks[vidx (lit)];
+    const signed char mask = 0x3f;
+#ifndef NDEBUG
+    const signed bits = m & mask;
+#endif
+    m &= mask;
+    assert ((m & mask) == bits);
+  }
+
+  void unmark (vector<int> & lits) {
+    for (const auto & lit : lits)
+      unmark (lit);
+  }
+
+  // The other 6 bits of the 'marks' bytes can be used as additional
+  // (unsigned) marking bits.  Currently we only use the least significant
+  // bit in 'condition' to mark variables in the conditional part.
+  //
+  bool getbit (int lit, int bit) const {
+    assert (0 <= bit), assert (bit < 6);
+    return marks[vidx (lit)] & (1<<bit);
+  }
+  void setbit (int lit, int bit) {
+    assert (0 <= bit), assert (bit < 6);
+    assert (!getbit (lit, bit));
+    marks[vidx (lit)] |= (1<<bit);
+    assert (getbit (lit, bit));
+  }
+  void unsetbit (int lit, int bit) {
+    assert (0 <= bit), assert (bit < 6);
+    assert (getbit (lit, bit));
+    marks[vidx (lit)] &= ~(1<<bit);
+    assert (!getbit (lit, bit));
+  }
+
+  // Marking individual literals.
+  //
+  bool marked2 (int lit) const {
+    unsigned res = marks [ vidx (lit) ];
+    assert (res <= 3);
+    unsigned bit = bign (lit);
+    return (res & bit) != 0;
+  }
+  void mark2 (int lit) {
+    marks[vidx (lit)] |= bign (lit);
+    assert (marked2 (lit));
+  }
+
+  // Marking and unmarking of all literals in a clause.
+  //
+  void mark_clause ();          // mark 'this->clause'
+  void mark (Clause *);
+  void mark2 (Clause *);
+  void unmark_clause ();        // unmark 'this->clause'
+  void unmark (Clause *);
+
+  // Watch literal 'lit' in clause with blocking literal 'blit'.
+  // Inlined here, since it occurs in the tight inner loop of 'propagate'.
+  //
+  inline void watch_literal (int lit, int blit, Clause * c) {
+    assert (lit != blit);
+    Watches & ws = watches (lit);
+    ws.push_back (Watch (blit, c));
+    LOG (c, "watch %d blit %d in", lit, blit);
+  }
+
+  // Add two watches to a clause.  This is used initially during allocation
+  // of a clause and during connecting back all watches after preprocessing.
+  //
+  inline void watch_clause (Clause * c) {
+    const int l0 = c->literals[0];
+    const int l1 = c->literals[1];
+    watch_literal (l0, l1, c);
+    watch_literal (l1, l0, c);
+  }
+
+  inline void unwatch_clause (Clause * c) {
+    const int l0 = c->literals[0];
+    const int l1 = c->literals[1];
+    remove_watch (watches (l0), c);
+    remove_watch (watches (l1), c);
+  }
+
+  // Update queue to point to last potentially still unassigned variable.
+  // All variables after 'queue.unassigned' in bump order are assumed to be
+  // assigned.  Then update the 'queue.bumped' field and log it.  This is
+  // inlined here since it occurs in several inner loops.
+  //
+  inline void update_queue_unassigned (int idx) {
+    assert (0 < idx);
+    assert (idx <= max_var);
+    queue.unassigned = idx;
+    queue.bumped = btab[idx];
+    LOG ("queue unassigned now %d bumped %" PRId64 "", idx, btab[idx]);
+  }
+
+  void bump_queue (int idx);
+
+  // Mark (active) variables as eliminated, substituted, pure or fixed,
+  // which turns them into inactive variables.
+  //
+  void mark_eliminated (int);
+  void mark_substituted (int);
+  void mark_active (int);
+  void mark_fixed (int);
+  void mark_pure (int);
+
+  // Managing clauses in 'clause.cpp'.  Without explicit 'Clause' argument
+  // these functions work on the global temporary 'clause'.
+  //
+  Clause * new_clause (bool red, int glue = 0);
+  void promote_clause (Clause *, int new_glue);
+  size_t shrink_clause (Clause *, int new_size);
+  void minimize_sort_clause();
+  void shrink_and_minimize_clause ();
+  void reset_shrinkable();
+  void mark_shrinkable_as_removable(int, std::vector<int>::size_type);
+  int shrink_literal(int, int, unsigned);
+  unsigned shrunken_block_uip(int, int, std::vector<int>::reverse_iterator &,
+                              std::vector<int>::reverse_iterator &,
+                              std::vector<int>::size_type, const int);
+  void shrunken_block_no_uip(const std::vector<int>::reverse_iterator&, const std::vector<int>::reverse_iterator&, unsigned&, const int);
+  void push_literals_of_block(const std::vector<int>::reverse_iterator&, const std::vector<int>::reverse_iterator&, int, unsigned);
+  unsigned shrink_next(unsigned&, unsigned&);
+  std::vector<int>::reverse_iterator minimize_and_shrink_block(std::vector<int>::reverse_iterator&, unsigned int&, unsigned int&, const int);
+  unsigned shrink_block(std::vector<int>::reverse_iterator&, std::vector<int>::reverse_iterator&, int, unsigned&, unsigned&, const int, unsigned);
+  unsigned shrink_along_reason(int, int, bool, bool&, unsigned);
+
+  void deallocate_clause(Clause *);
+  void delete_clause (Clause *);
+  void mark_garbage (Clause *);
+  void assign_original_unit (int);
+  void add_new_original_clause ();
+  Clause * new_learned_redundant_clause (int glue);
+  Clause * new_hyper_binary_resolved_clause (bool red, int glue);
+  Clause * new_clause_as (const Clause * orig);
+  Clause * new_resolved_irredundant_clause ();
+
+  // Forward reasoning through propagation in 'propagate.cpp'.
+  //
+  int assignment_level (int lit, Clause*);
+  void search_assign (int lit, Clause *);
+  void search_assign_driving (int lit, Clause * reason);
+  void search_assume_decision (int decision);
+  void assign_unit (int lit);
+  bool propagate ();
+
+  // Undo and restart in 'backtrack.cpp'.
+  //
+  void unassign (int lit);
+  void update_target_and_best ();
+  void backtrack (int target_level = 0);
+
+  // Minimized learned clauses in 'minimize.cpp'.
+  //
+  bool minimize_literal (int lit, int depth = 0);
+  void minimize_clause ();
+
+  // Learning from conflicts in 'analyze.cc'.
+  //
+  void learn_empty_clause ();
+  void learn_unit_clause (int lit);
+  void bump_variable (int lit);
+  void bump_variables ();
+  int recompute_glue (Clause *);
+  void bump_clause (Clause *);
+  void clear_analyzed_literals ();
+  void clear_analyzed_levels ();
+  void clear_minimized_literals ();
+  bool bump_also_reason_literal (int lit);
+  void bump_also_reason_literals (int lit, int limit);
+  void bump_also_all_reason_literals ();
+  void analyze_literal (int lit, int & open);
+  void analyze_reason (int lit, Clause *, int & open);
+  Clause * new_driving_clause (const int glue, int & jump);
+  int find_conflict_level (int & forced);
+  int determine_actual_backtrack_level (int jump);
+  void analyze ();
+  void iterate ();       // report learned unit clause
+
+  // Use last learned clause to subsume some more.
+  //
+  void eagerly_subsume_recently_learned_clauses (Clause *);
+
+  // Restarting policy in 'restart.cc'.
+  //
+  bool stabilizing ();
+  bool restarting ();
+  int reuse_trail ();
+  void restart ();
+
+  // Functions to set and reset certain 'phases'.
+  //
+  void clear_phases (vector<signed char> &);  // reset argument to zero
+  void copy_phases (vector<signed char> &);   // copy 'saved' to argument
+
+  // Resetting the saved phased in 'rephase.cpp'.
+  //
+  bool rephasing ();
+  char rephase_best ();
+  char rephase_flipping ();
+  char rephase_inverted ();
+  char rephase_original ();
+  char rephase_random ();
+  char rephase_walk ();
+  void shuffle_scores ();
+  void shuffle_queue ();
+  void rephase ();
+
+  // Lucky feasible case checking.
+  //
+  int unlucky (int res);
+  int trivially_false_satisfiable ();
+  int trivially_true_satisfiable ();
+  int forward_false_satisfiable ();
+  int forward_true_satisfiable ();
+  int backward_false_satisfiable ();
+  int backward_true_satisfiable ();
+  int positive_horn_satisfiable ();
+  int negative_horn_satisfiable ();
+
+  // Asynchronous terminating check.
+  //
+  bool terminated_asynchronously (int factor = 1);
+
+  bool search_limits_hit ();
+
+  void terminate () {
+    LOG ("forcing asynchronous termination");
+    termination_forced = true;
+  }
+
+  // Reducing means determining useless clauses with 'reduce' in
+  // 'reduce.cpp' as well as root level satisfied clause and then removing
+  // those which are not used as reason anymore with garbage collection.
+  //
+  bool flushing ();
+  bool reducing ();
+  void protect_reasons ();
+  void mark_clauses_to_be_flushed ();
+  void mark_useless_redundant_clauses_as_garbage ();
+  bool propagate_out_of_order_units ();
+  void unprotect_reasons ();
+  void reduce ();
+
+  // Garbage collection in 'collect.cpp' called from 'reduce' and during
+  // inprocessing and preprocessing.
+  //
+  int clause_contains_fixed_literal (Clause *);
+  void remove_falsified_literals (Clause *);
+  void mark_satisfied_clauses_as_garbage ();
+  void copy_clause (Clause *);
+  void flush_watches (int lit, Watches &);
+  size_t flush_occs (int lit);
+  void flush_all_occs_and_watches ();
+  void update_reason_references ();
+  void copy_non_garbage_clauses ();
+  void delete_garbage_clauses ();
+  void check_clause_stats ();
+  void check_var_stats ();
+  bool arenaing ();
+  void garbage_collection ();
+
+  // Set-up occurrence list counters and containers.
+  //
+  void init_occs ();
+  void init_bins ();
+  void init_noccs ();
+  void reset_occs ();
+  void reset_bins ();
+  void reset_noccs ();
+
+  // Operators on watches.
+  //
+  void init_watches ();
+  void connect_watches (bool irredundant_only = false);
+  void sort_watches ();
+  void clear_watches ();
+  void reset_watches ();
+
+  // Regular forward subsumption checking in 'subsume.cpp'.
+  //
+  bool subsuming ();
+  void strengthen_clause (Clause *, int);
+  void subsume_clause (Clause * subsuming, Clause * subsumed);
+  int subsume_check (Clause * subsuming, Clause * subsumed);
+  int try_to_subsume_clause (Clause *, vector<Clause*> & shrunken);
+  void reset_subsume_bits ();
+  bool subsume_round ();
+  void subsume (bool update_limits = true);
+
+  // Covered clause elimination of large clauses.
+  //
+  void covered_literal_addition (int lit, Coveror &);
+  void asymmetric_literal_addition (int lit, Coveror &);
+  void cover_push_extension (int lit, Coveror &);
+  bool cover_propagate_asymmetric (int lit, Clause * ignore, Coveror &);
+  bool cover_propagate_covered (int lit, Coveror &);
+  bool cover_clause (Clause * c, Coveror &);
+  int64_t cover_round ();
+  bool cover ();
+
+  // Strengthening through vivification in 'vivify.cpp'.
+  //
+  void flush_vivification_schedule (Vivifier &);
+  bool consider_to_vivify_clause (Clause * candidate, bool redundant_mode);
+  void vivify_analyze_redundant (Vivifier &, Clause * start, bool &);
+  bool vivify_all_decisions (Clause * candidate, int subsume);
+  void vivify_post_process_analysis (Clause * candidate, int subsume);
+  void vivify_strengthen (Clause * candidate);
+  void vivify_assign (int lit, Clause *);
+  void vivify_assume (int lit);
+  bool vivify_propagate ();
+  void vivify_clause (Vivifier &, Clause * candidate);
+  void vivify_round (bool redundant_mode, int64_t delta);
+  void vivify ();
+
+  // Compacting (shrinking internal variable tables) in 'compact.cpp'
+  //
+  bool compacting ();
+  void compact ();
+
+  // Transitive reduction of binary implication graph in 'transred.cpp'
+  //
+  void transred ();
+
+  // We monitor the maximum size and glue of clauses during 'reduce' and
+  // thus can predict if a redundant extended clause is likely to be kept in
+  // the next 'reduce' phase.  These clauses are target of subsumption and
+  // vivification checks, in addition to irredundant clauses.  Their
+  // variables are also marked as being 'added'.
+  //
+  bool likely_to_be_kept_clause (Clause * c) {
+    if (!c->redundant) return true;
+    if (c->keep) return true;
+    if (c->glue > lim.keptglue) return false;
+    if (c->size > lim.keptsize) return false;
+    return true;
+  }
+
+  // We mark variables in added or shrunken clauses as 'subsume' candidates
+  // if the clause is likely to be kept in the next 'reduce' phase (see last
+  // function above).  This gives a persistent (across consecutive
+  // interleaved search and inprocessing phases) set of variables which have
+  // to be reconsidered in subsumption checks, i.e., only clauses with
+  // 'subsume' marked variables are checked to be forward subsumed.
+  // A similar technique is used to reduce the effort in hyper ternary
+  // resolution to focus on variables in new ternary clauses.
+  //
+  void mark_subsume (int lit) {
+    Flags & f = flags (lit);
+    if (f.subsume) return;
+    LOG ("marking %d as subsuming literal candidate", abs (lit));
+    stats.mark.subsume++;
+    f.subsume = true;
+  }
+  void mark_ternary (int lit) {
+    Flags & f = flags (lit);
+    if (f.ternary) return;
+    LOG ("marking %d as ternary resolution literal candidate", abs (lit));
+    stats.mark.ternary++;
+    f.ternary = true;
+  }
+  void mark_added (int lit, int size, bool redundant);
+  void mark_added (Clause *);
+
+  bool marked_subsume(int lit) const { return flags(lit).subsume; }
+
+    // If irredundant clauses are removed or literals in clauses are removed,
+    // then variables in such clauses should be reconsidered to be eliminated
+    // through bounded variable elimination.  In contrast to 'subsume' the
+    // 'elim' flag is restricted to 'irredundant' clauses only. For blocked
+    // clause elimination it is better to have a more precise signed version,
+    // which allows to independently mark positive and negative literals.
+    //
+    void mark_elim(int lit) {
+      Flags &f = flags(lit);
+      if (f.elim)
+        return;
+      LOG("marking %d as elimination literal candidate", lit);
+      stats.mark.elim++;
+      f.elim = true;
+    }
+    void mark_block(int lit) {
+      Flags &f = flags(lit);
+      const unsigned bit = bign(lit);
+      if (f.block & bit)
+        return;
+      LOG("marking %d as blocking literal candidate", lit);
+      stats.mark.block++;
+      f.block |= bit;
+    }
+    void mark_removed(int lit) {
+      mark_elim(lit);
+      mark_block(-lit);
+    }
+    void mark_removed(Clause *, int except = 0);
+
+    // The following two functions are only used for testing & debugging.
+
+    bool marked_block(int lit) const {
+      const Flags &f = flags(lit);
+      const unsigned bit = bign(lit);
+      return (f.block & bit) != 0;
+    }
+    void unmark_block(int lit) {
+      Flags &f = flags(lit);
+      const unsigned bit = bign(lit);
+      f.block &= ~bit;
+    }
+
+    // During scheduling literals for blocked clause elimination we skip those
+    // literals which occur negated in a too large clause.
+    //
+    void mark_skip(int lit) {
+      Flags &f = flags(lit);
+      const unsigned bit = bign(lit);
+      if (f.skip & bit)
+        return;
+      LOG("marking %d to be skipped as blocking literal", lit);
+      f.skip |= bit;
+    }
+    bool marked_skip(int lit) {
+      const Flags &f = flags(lit);
+      const unsigned bit = bign(lit);
+      return (f.skip & bit) != 0;
+    }
+
+    // Blocked Clause elimination in 'block.cpp'.
+    //
+    bool is_blocked_clause(Clause * c, int pivot);
+    void block_schedule(Blocker &);
+    size_t block_candidates(Blocker &, int lit);
+    Clause *block_impossible(Blocker &, int lit);
+    void block_literal_with_at_least_two_negative_occs(Blocker &, int lit);
+    void block_literal_with_one_negative_occ(Blocker &, int lit);
+    void block_pure_literal(Blocker &, int lit);
+    void block_reschedule_clause(Blocker &, int lit, Clause *);
+    void block_reschedule(Blocker &, int lit);
+    void block_literal(Blocker &, int lit);
+    bool block();
+
+    // Find gates in 'gates.cpp' for bounded variable substitution.
+    //
+    int second_literal_in_binary_clause(Eliminator &, Clause *, int first);
+    void mark_binary_literals(Eliminator &, int pivot);
+    void find_and_gate(Eliminator &, int pivot);
+    void find_equivalence(Eliminator &, int pivot);
+
+    bool get_ternary_clause(Clause *, int &, int &, int &);
+    bool match_ternary_clause(Clause *, int, int, int);
+    Clause *find_ternary_clause(int, int, int);
+
+    bool get_clause(Clause *, vector<int> &);
+    bool is_clause(Clause *, const vector<int> &);
+    Clause *find_clause(const vector<int> &);
+    void find_xor_gate(Eliminator &, int pivot);
+
+    void find_if_then_else(Eliminator &, int pivot);
+
+    void find_gate_clauses(Eliminator &, int pivot);
+    void unmark_gate_clauses(Eliminator &);
+
+    // Bounded variable elimination in 'elim.cpp'.
+    //
+    bool eliminating();
+    double compute_elim_score(unsigned lit);
+    void mark_redundant_clauses_with_eliminated_variables_as_garbage();
+    void unmark_binary_literals(Eliminator &);
+    bool resolve_clauses(Eliminator &, Clause *, int pivot, Clause *, bool);
+    void mark_eliminated_clauses_as_garbage(Eliminator &, int pivot);
+    bool elim_resolvents_are_bounded(Eliminator &, int pivot);
+    void elim_update_removed_lit(Eliminator &, int lit);
+    void elim_update_removed_clause(Eliminator &, Clause *, int except = 0);
+    void elim_update_added_clause(Eliminator &, Clause *);
+    void elim_add_resolvents(Eliminator &, int pivot);
+    void elim_backward_clause(Eliminator &, Clause *);
+    void elim_backward_clauses(Eliminator &);
+    void elim_propagate(Eliminator &, int unit);
+    void elim_on_the_fly_self_subsumption(Eliminator &, Clause *, int);
+    void try_to_eliminate_variable(Eliminator &, int pivot);
+    void increase_elimination_bound();
+    int elim_round(bool &completed);
+    void elim(bool update_limits = true);
+
+    void inst_assign(int lit);
+    bool inst_propagate();
+    void collect_instantiation_candidates(Instantiator &);
+    bool instantiate_candidate(int lit, Clause *);
+    void instantiate(Instantiator &);
+
+    // Hyper ternary resolution.
+    //
+    bool ternary_find_binary_clause(int, int);
+    bool ternary_find_ternary_clause(int, int, int);
+    Clause *new_hyper_ternary_resolved_clause(bool red);
+    bool hyper_ternary_resolve(Clause *, int, Clause *);
+    void ternary_lit(int pivot, int64_t &steps, int64_t &htrs);
+    void ternary_idx(int idx, int64_t &steps, int64_t &htrs);
+    bool ternary_round(int64_t & steps, int64_t & htrs);
+    bool ternary();
+
+    // Probing in 'probe.cpp'.
+    //
+    bool probing();
+    void failed_literal(int lit);
+    void probe_assign_unit(int lit);
+    void probe_assign_decision(int lit);
+    void probe_assign(int lit, int parent);
+    void mark_duplicated_binary_clauses_as_garbage();
+    int get_parent_reason_literal(int lit);
+    void set_parent_reason_literal(int lit, int reason);
+    int probe_dominator(int a, int b);
+    int hyper_binary_resolve(Clause *);
+    void probe_propagate2();
+    bool probe_propagate();
+    bool is_binary_clause(Clause * c, int &, int &);
+    void generate_probes();
+    void flush_probes();
+    int next_probe();
+    bool probe_round();
+    void probe(bool update_limits = true);
+
+    // ProbSAT/WalkSAT implementation called initially or from 'rephase'.
+    //
+    void walk_save_minimum(Walker &);
+    Clause *walk_pick_clause(Walker &);
+    unsigned walk_break_value(int lit);
+    int walk_pick_lit(Walker &, Clause *);
+    void walk_flip_lit(Walker &, int lit);
+    int walk_round(int64_t limit, bool prev);
+    void walk();
+
+    // Detect strongly connected components in the binary implication graph
+    // (BIG) and equivalent literal substitution (ELS) in 'decompose.cpp'.
+    //
+    bool decompose_round();
+    void decompose();
+
+    // Assumption handling.
+    //
+    void assume(int);         // New assumption literal.
+    void reset_assumptions(); // Reset after 'solve' call.
+    void reset_limits();      // Reset after 'solve' call.
+    void failing();           // Prepare failed assumptions.
+
+    bool failed(int lit) { // Literal failed assumption?
+      Flags &f = flags(lit);
+      const unsigned bit = bign(lit);
+      return (f.failed & bit) != 0;
+    }
+
+    bool assumed(int lit) { // Marked as assumption.
+      Flags &f = flags(lit);
+      const unsigned bit = bign(lit);
+      return (f.assumed & bit) != 0;
+    }
+
+    // Forcing decision variables to a certain phase.
+    //
+    void phase(int lit);
+    void unphase(int lit);
+
+    // Globally blocked clause elimination.
+    //
+    bool is_autarky_literal(int lit) const;
+    bool is_conditional_literal(int lit) const;
+    void mark_as_conditional_literal(int lit);
+    void unmark_as_conditional_literal(int lit);
+    //
+    bool is_in_candidate_clause(int lit) const;
+    void mark_in_candidate_clause(int lit);
+    void unmark_in_candidate_clause(int lit);
+    //
+    void condition_assign(int lit);
+    void condition_unassign(int lit);
+    //
+    bool conditioning();
+    long condition_round(long unassigned_literal_propagation_limit);
+    void condition(bool update_limits = true);
+
+    // Part on picking the next decision in 'decide.cpp'.
+    //
+    bool satisfied();
+    int next_decision_variable_on_queue();
+    int next_decision_variable_with_best_score();
+    int next_decision_variable();
+    int decide_phase(int idx, bool target);
+    int likely_phase(int idx);
+    int decide(); // 0=decision, 20=failed
+
+    // Internal functions to enable explicit search limits.
+    //
+    void limit_terminate(int);
+    void limit_decisions(int);     // Force decision limit.
+    void limit_conflicts(int);     // Force conflict limit.
+    void limit_preprocessing(int); // Enable 'n' preprocessing rounds.
+    void limit_local_search(int);  // Enable 'n' local search rounds.
+
+    // External versions can access limits by 'name'.
+    //
+    static bool is_valid_limit(const char *name);
+    bool limit(const char *name, int); // 'true' if 'name' valid
+
+    // Set all the CDCL search limits and increments for scheduling
+    // inprocessing, restarts, clause database reductions, etc.
+    //
+    void init_report_limits();
+    void init_preprocessing_limits();
+    void init_search_limits();
+
+    // The computed averages are local to the 'stable' and 'unstable' phase.
+    // Their main use is to be reported in 'report', except for the 'glue'
+    // averages, which are used to schedule (prohibit actually) restarts
+    // during 'unstable' phases ('stable' phases use reluctant doubling).
+    //
+    void init_averages();
+    void swap_averages();
+
+    int try_to_satisfy_formula_by_saved_phases();
+    void produce_failed_assumptions();
+
+    // Main solve & search functions in 'internal.cpp'.
+    //
+    // We have three pre-solving techniques.  These consist of preprocessing,
+    // local search and searching for lucky phases, which in full solving
+    // mode except for the last are usually optional and then followed by
+    // the main CDCL search loop with inprocessing.  If only preprocessing
+    // is requested from 'External::simplifiy' only preprocessing is called
+    // though. This is all orchestrated by the 'solve' function.
+    //
+    int already_solved();
+    int restore_clauses();
+    bool preprocess_round(int round);
+    int preprocess();
+    int local_search_round(int round);
+    int local_search();
+    int lucky_phases();
+    int cdcl_loop_with_inprocessing();
+    void reset_solving();
+    int solve(bool preprocess_only = false);
+
+    //
+    int lookahead();
+    CubesWithStatus generate_cubes(int, int);
+    int most_occurring_literal();
+    int lookahead_probing();
+    int lookahead_next_probe();
+    void lookahead_flush_probes();
+    void lookahead_generate_probes();
+    std::vector<int> lookahead_populate_locc();
+    int lookahead_locc(const std::vector<int> &);
+
+    bool terminating_asked();
+
+#ifndef QUIET
+  // Built in profiling in 'profile.cpp' (see also 'profile.hpp').
+  //
+  void start_profiling (Profile & p, double);
+  void stop_profiling (Profile & p, double);
+
+  double update_profiles ();    // Returns 'time ()'.
+  void print_profile ();
+#endif
+
+  // Get the value of an internal literal: -1=false, 0=unassigned, 1=true.
+  // We use a redundant table for both negative and positive literals.  This
+  // allows a branch-less check for the value of literal and is considered
+  // substantially faster than negating the result if the argument is
+  // negative.  We also avoid taking the absolute value.
+  //
+  signed char val (int lit) const {
+    assert (-max_var <= lit);
+    assert (lit);
+    assert (lit <= max_var);
+    return vals[lit];
+  }
+
+  // As 'val' but restricted to the root-level value of a literal.
+  // It is not that time critical and also needs to check the decision level
+  // of the variable anyhow.
+  //
+  int fixed (int lit) {
+    assert (-max_var <= lit);
+    assert (lit);
+    assert (lit <= max_var);
+    const int idx = vidx (lit);
+    int res = vals[idx];
+    if (res && vtab[idx].level) res = 0;
+    if (lit < 0) res = -res;
+    return res;
+  }
+
+  // Map back an internal literal to an external.
+  //
+  int externalize (int lit) {
+    assert (lit != INT_MIN);
+    const int idx = abs (lit);
+    assert (idx);
+    assert (idx <= max_var);
+    int res = i2e[idx];
+    if (lit < 0) res = -res;
+    return res;
+  }
+
+  // Explicit freezing and melting of variables.
+  //
+  void freeze (int lit) {
+    int idx = vidx (lit);
+    unsigned & ref = frozentab[idx];
+    if (ref < UINT_MAX) {
+      ref++;
+      LOG ("variable %d frozen %u times", idx, ref);
+    } else LOG ("variable %d remains frozen forever", idx);
+  }
+  void melt (int lit) {
+    int idx = vidx (lit);
+    unsigned & ref = frozentab[idx];
+    if (ref < UINT_MAX) {
+      if (!--ref) {
+        LOG ("variable %d completely molten", idx);
+      } else
+        LOG ("variable %d melted once but remains frozen %u times",
+          lit, ref);
+    } else LOG ("variable %d remains frozen forever", idx);
+  }
+  bool frozen (int lit) { return frozentab[vidx (lit)] > 0; }
+
+  // Parsing functions in 'parse.cpp'.
+  //
+  const char * parse_dimacs (FILE *);
+  const char * parse_dimacs (const char *);
+  const char * parse_solution (const char *);
+
+  // Enable and disable proof logging and checking.
+  //
+  void new_proof_on_demand ();
+  void close_trace ();          // Stop proof tracing.
+  void flush_trace ();          // Flush proof trace file.
+  void trace (File *);          // Start write proof file.
+  void check ();                // Enable online proof checking.
+
+  // Dump to '<stdout>' as DIMACS for debugging.
+  //
+  void dump (Clause *);
+  void dump ();
+
+  // Export and traverse all irredundant (non-unit) clauses.
+  //
+  bool traverse_clauses (ClauseIterator &);
+
+  /*----------------------------------------------------------------------*/
+
+  double solve_time ();         // accumulated time spent in 'solve ()'
+
+  double process_time ();       // since solver was initialized
+  double real_time ();          // since solver was initialized
+
+  double time () {
+    return opts.realtime ? real_time () : process_time ();
+  }
+
+  // Regularly reports what is going on in 'report.cpp'.
+  //
+  void report (char type, int verbose_level = 0);
+  void report_solving(int);
+
+  void print_statistics ();
+  void print_resource_usage ();
+
+  /*----------------------------------------------------------------------*/
+
+#ifndef QUIET
+
+  void print_prefix ();
+
+  // Non-verbose messages and warnings, i.e., always printed unless 'quiet'
+  // is set, which disables messages at run-time, or even 'QUIET' is defined
+  // through the configuration option './configure --quiet', which disables
+  // such messages completely at compile-time.
+  //
+  void vmessage (const char *, va_list &);
+  void message (const char *, ...)
+                CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  void message ();                              // empty line
+
+  // Verbose messages with explicit verbose 'level' controlled by
+  // 'opts.verbose' (verbose level '0' gives the same as 'message').
+  //
+  void vverbose (int level, const char * fmt, va_list &);
+  void verbose (int level, const char * fmt, ...)
+                CADICAL_ATTRIBUTE_FORMAT (3, 4);
+  void verbose (int level);
+
+  // This is for printing section headers in the form
+  //
+  //  c ---- [ <title> ] ---------------------
+  //
+  // nicely aligned (and of course is ignored if 'quiet' is set).
+  //
+  void section (const char * title);
+
+  // Print verbose message about phases if 'opts.verbose > 1' (but not if
+  // 'quiet' is set).  Note that setting 'log' or '-l' forces all verbose
+  // output (and also ignores 'quiet' set to true').  The 'phase' argument
+  // is used to print a 'phase' prefix for the message as follows:
+  //
+  //  c [<phase>] ...
+  //
+  void phase (const char * phase, const char *, ...)
+              CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  // Same as the last 'phase' above except that the prefix gets a count:
+  //
+  //  c [<phase>-<count>] ...
+  //
+  void phase (const char * phase, int64_t count, const char *, ...)
+              CADICAL_ATTRIBUTE_FORMAT (4, 5);
+#endif
+
+  // Print error messages which are really always printed (even if 'quiet'
+  // is set).  This leads to exit the current process with exit status '1'.
+  //
+  // TODO add possibility to use a call back instead of calling exit.
+  //
+  void error_message_end ();
+  void verror (const char *, va_list &);
+  void error (const char *, ...)
+              CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  void error_message_start ();
+
+  // Warning messages.
+  //
+  void warning (const char *, ...)
+                CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  };
+
+// Fatal internal error which leads to abort.
+//
+void fatal_message_start ();
+void fatal_message_end ();
+void fatal (const char *, ...)
+            CADICAL_ATTRIBUTE_FORMAT (1, 2);
+
+/*------------------------------------------------------------------------*/
+
+// Has to be put here, i.e., not into 'score.hpp', since we need the
+// definition of 'Internal::score' above (after '#include "score.hpp"').
+
+inline bool score_smaller::operator () (unsigned a, unsigned b) {
+
+  // Avoid computing twice 'abs' in 'score ()'.
+  //
+  assert (1 <= a);
+  assert (a <= (unsigned) internal->max_var);
+  assert (1 <= b);
+  assert (b <= (unsigned) internal->max_var);
+  double s = internal->stab[a];
+  double t = internal->stab[b];
+
+  if (s < t) return true;
+  if (s > t) return false;
+
+  return a > b;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Implemented here for keeping it all inline (requires Internal::fixed).
+
+inline int External::fixed (int elit) const {
+  assert (elit);
+  assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var) return 0;
+  int ilit = e2i [eidx];
+  if (!ilit) return 0;
+  if (elit < 0) ilit = -ilit;
+  return internal->fixed (ilit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// We want to have termination checks inlined, particularly the first
+// function which appears in preprocessor loops.  Even though this first
+// 'termination_forced' is set asynchronously, this should not lead to a
+// data race issue (it also has been declared 'volatile').
+
+inline bool Internal::terminated_asynchronously (int factor)
+{
+  // First way of asynchronous termination is through 'terminate' which sets
+  // the 'termination_forced' flag directly.  The second way is through a
+  // call back to a 'terminator' if it is non-zero, which however is costly.
+  //
+  if (termination_forced)
+  {
+    LOG ("termination asynchronously forced");
+    return true;
+  }
+
+  // This is only for testing and debugging asynchronous termination calls.
+  // In production code this could be removed but then should not be costly
+  // and keeping it will allow to test correctness of asynchronous
+  // termination on the production platform too.  After this triggers we
+  // have to set the 'termination_forced' flag, such that subsequent calls
+  // to this function do not check this again.
+  //
+  if (lim.terminate.forced) {
+    assert (lim.terminate.forced > 0);
+    if (lim.terminate.forced-- == 1) {
+      LOG ("internally forcing termination");
+      termination_forced = true;
+      return true;
+    }
+    LOG ("decremented internal forced termination limit to %d",
+      lim.terminate.forced);
+  }
+
+  // The second way of asynchronous termination is through registering and
+  // calling an external 'Terminator' object.  This is of course more costly
+  // than just checking a (volatile though) boolean flag, particularly in
+  // tight loops.  To avoid this cost we only call the terminator in
+  // intervals of 'opts.terminateint', which in addition can be scaled up by
+  // the argument 'factor'.  If the terminator returns 'true' we set the
+  // 'termination_forced' flag to 'true' in order to remember the
+  // termination status and to avoid the terminator again.  Setting this
+  // flag leads to the first test above to succeed in subsequent calls.
+  //
+  if (external->terminator && !lim.terminate.check--) {
+    assert (factor > 0);
+    assert (INT_MAX/factor > opts.terminateint);
+    lim.terminate.check = factor * opts.terminateint;
+    if (external->terminator->terminate ()) {
+      termination_forced = true;                        // Cache it.
+      LOG ("connected terminator forces termination");
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline bool Internal::search_limits_hit ()
+{
+  assert (!preprocessing);
+  assert (!localsearching);
+
+  if (lim.conflicts >= 0 &&
+      stats.conflicts >= lim.conflicts) {
+    LOG ("conflict limit %" PRId64 " reached", lim.conflicts);
+    return true;
+  }
+
+  if (lim.decisions >= 0 &&
+      stats.decisions >= lim.decisions) {
+    LOG ("decision limit %" PRId64 " reached", lim.decisions);
+    return true;
+  }
+
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+}
+
+#endif
diff --git a/hCaD_V2/src/ipasir.cpp b/hCaD_V2/src/ipasir.cpp
new file mode 100644
index 0000000..90f8093
--- /dev/null
+++ b/hCaD_V2/src/ipasir.cpp
@@ -0,0 +1,48 @@
+#include "ipasir.h"
+#include "ccadical.h"
+
+extern "C" {
+
+const char * ipasir_signature () {
+  return ccadical_signature ();
+}
+
+void * ipasir_init () {
+  return ccadical_init (); }
+
+void ipasir_release (void * solver) {
+  ccadical_release ((CCaDiCaL*) solver);
+}
+
+void ipasir_add (void * solver, int lit) {
+  ccadical_add ((CCaDiCaL *) solver, lit);
+}
+
+void ipasir_assume (void * solver, int lit) {
+  ccadical_assume ((CCaDiCaL *) solver, lit);
+}
+
+int ipasir_solve (void * solver) {
+  return ccadical_solve ((CCaDiCaL *) solver);
+}
+
+int ipasir_val (void * solver, int lit) {
+  return ccadical_val ((CCaDiCaL *) solver, lit);
+}
+
+int ipasir_failed (void * solver, int lit) {
+  return ccadical_failed ((CCaDiCaL *) solver, lit);
+}
+
+void ipasir_set_terminate (void * solver,
+                           void * state, int (*terminate)(void * state)) {
+  ccadical_set_terminate ((CCaDiCaL *) solver, state, terminate);
+}
+
+void ipasir_set_learn (void * solver,
+                         void * state, int max_length,
+                         void (*learn)(void * state, int * clause)) {
+  ccadical_set_learn ((CCaDiCaL*) solver, state, max_length, learn);
+}
+
+}
diff --git a/hCaD_V2/src/ipasir.h b/hCaD_V2/src/ipasir.h
new file mode 100644
index 0000000..f54ee58
--- /dev/null
+++ b/hCaD_V2/src/ipasir.h
@@ -0,0 +1,38 @@
+#ifndef _ipasir_h_INCLUDED
+#define _ipasir_h_INCLUDED
+
+/*------------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*------------------------------------------------------------------------*/
+
+// Here are the declarations for the actual IPASIR functions, which is the
+// generic incremental reentrant SAT solver API used for instance in the SAT
+// competition.  The other 'C' API in 'ccadical.h' is (more) type safe and
+// has additional functions only supported by the CaDiCaL library.  Please
+// also refer to our SAT Race 2015 article in the Journal of AI from 2016.
+
+const char * ipasir_signature (void);
+void * ipasir_init (void);
+void ipasir_release (void * solver);
+void ipasir_add (void * solver, int lit);
+void ipasir_assume (void * solver, int lit);
+int ipasir_solve (void * solver);
+int ipasir_val (void * solver, int lit);
+int ipasir_failed (void * solver, int lit);
+
+void ipasir_set_terminate (void * solver,
+                           void * state, int (*terminate)(void * state));
+
+void ipasir_set_learn (void * solver,
+                       void * state, int max_length,
+		       void (*learn)(void * state, int * clause));
+
+/*------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/hCaD_V2/src/level.hpp b/hCaD_V2/src/level.hpp
new file mode 100644
index 0000000..f583ad8
--- /dev/null
+++ b/hCaD_V2/src/level.hpp
@@ -0,0 +1,30 @@
+#ifndef _level_hpp_INCLUDED
+#define _level_hpp_INCLUDED
+
+#include <climits>
+
+namespace CaDiCaL {
+
+// For each new decision we increase the decision level and push a 'Level'
+// on the 'control' stack.  The information gathered here is used in
+// 'reuse_trail' and for early aborts in clause minimization.
+
+struct Level {
+
+  int decision;         // decision literal of this level
+  int trail;            // trail start of this level
+
+  struct {
+    int count;          // how many variables seen during 'analyze'
+    int trail;          // smallest trail position seen on this level
+  } seen;
+
+  void reset () { seen.count = 0; seen.trail = INT_MAX; }
+
+  Level (int d, int t) : decision (d), trail (t) { reset (); }
+  Level () { }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/limit.cpp b/hCaD_V2/src/limit.cpp
new file mode 100644
index 0000000..86e74b7
--- /dev/null
+++ b/hCaD_V2/src/limit.cpp
@@ -0,0 +1,122 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+Limit::Limit () {
+  memset (this, 0, sizeof *this);
+}
+
+/*------------------------------------------------------------------------*/
+
+double Internal::scale (double v) const {
+  const double ratio = clause_variable_ratio ();
+  const double factor = (ratio <= 2) ? 1.0 : log (ratio) / log (2);
+  double res = factor * v;
+  if (res < 1) res = 1;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+Last::Last () {
+  memset (this, 0, sizeof *this);
+}
+
+/*------------------------------------------------------------------------*/
+
+Inc::Inc () {
+  memset (this, 0, sizeof *this);
+  decisions = conflicts = -1;           // unlimited
+}
+
+void Internal::limit_terminate (int l) {
+  if (l <= 0 && !lim.terminate.forced) {
+    LOG ("keeping unbounded terminate limit");
+  } else if (l <= 0) {
+    LOG ("reset terminate limit to be unbounded");
+    lim.terminate.forced = 0;
+  } else {
+    lim.terminate.forced = l;
+    LOG ("new terminate limit of %d calls", l);
+  }
+}
+
+void Internal::limit_conflicts (int l) {
+  if (l < 0 && inc.conflicts < 0) {
+    LOG ("keeping unbounded conflict limit");
+  } else if (l < 0) {
+    LOG ("reset conflict limit to be unbounded");
+    inc.conflicts = -1;
+  } else {
+    inc.conflicts = l;
+    LOG ("new conflict limit of %d conflicts", l);
+  }
+}
+
+void Internal::limit_decisions (int l) {
+  if (l < 0 && inc.decisions < 0) {
+    LOG ("keeping unbounded decision limit");
+  } else if (l < 0) {
+    LOG ("reset decision limit to be unbounded");
+    inc.decisions = -1;
+  } else {
+    inc.decisions = l;
+    LOG ("new decision limit of %d decisions", l);
+  }
+}
+
+void Internal::limit_preprocessing (int l) {
+  if (l < 0) {
+    LOG ("ignoring invalid preprocessing limit %d", l);
+  } else if (!l) {
+    LOG ("reset preprocessing limit to no preprocessing");
+    inc.preprocessing = 0;
+  } else {
+    inc.preprocessing = l;
+    LOG ("new preprocessing limit of %d preprocessing rounds", l);
+  }
+}
+
+void Internal::limit_local_search (int l) {
+  if (l < 0) {
+    LOG ("ignoring invalid local search limit %d", l);
+  } else if (!l) {
+    LOG ("reset local search limit to no local search");
+    inc.localsearch = 0;
+  } else {
+    inc.localsearch = l;
+    LOG ("new local search limit of %d local search rounds", l);
+  }
+}
+
+bool Internal::is_valid_limit (const char * name) {
+  if (!strcmp (name, "terminate")) return true;
+  if (!strcmp (name, "conflicts")) return true;
+  if (!strcmp (name, "decisions")) return true;
+  if (!strcmp (name, "preprocessing")) return true;
+  if (!strcmp (name, "localsearch")) return true;
+  return false;
+}
+
+bool Internal::limit (const char * name, int l) {
+  bool res = true;
+       if (!strcmp (name, "terminate")) limit_terminate (l);
+  else if (!strcmp (name, "conflicts")) limit_conflicts (l);
+  else if (!strcmp (name, "decisions")) limit_decisions (l);
+  else if (!strcmp (name, "preprocessing")) limit_preprocessing (l);
+  else if (!strcmp (name, "localsearch")) limit_local_search (l);
+  else res = false;
+  return res;
+}
+
+void Internal::reset_limits () {
+  LOG ("reset limits");
+  limit_terminate (0);
+  limit_conflicts (-1);
+  limit_decisions (-1);
+  limit_preprocessing (0);
+  limit_local_search (0);
+}
+
+}
+
diff --git a/hCaD_V2/src/limit.hpp b/hCaD_V2/src/limit.hpp
new file mode 100644
index 0000000..66eef0b
--- /dev/null
+++ b/hCaD_V2/src/limit.hpp
@@ -0,0 +1,68 @@
+#ifndef _limit_hpp_INCLUDED
+#define _limit_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Limit {
+
+  bool initialized;
+
+  int64_t conflicts;       // conflict limit if non-negative
+  int64_t decisions;       // decision limit if non-negative
+  int64_t preprocessing;   // limit on preprocessing rounds
+  int64_t localsearch;     // limit on local search rounds
+
+  int64_t compact;         // conflict limit for next 'compact'
+  int64_t condition;       // conflict limit for next 'condition'
+  int64_t elim;            // conflict limit for next 'elim'
+  int64_t flush;           // conflict limit for next 'flush'
+  int64_t probe;           // conflict limit for next 'probe'
+  int64_t reduce;          // conflict limit for next 'reduce'
+  int64_t rephase;         // conflict limit for next 'rephase'
+  int64_t report;          // report limit for header
+  int64_t restart;         // conflict limit for next 'restart'
+  int64_t stabilize;       // conflict limit for next 'stabilize'
+  int64_t subsume;         // conflict limit for next 'subsume'
+
+  int keptsize;            // maximum kept size in 'reduce'
+  int keptglue;            // maximum kept glue in 'reduce'
+
+  // How often rephased during (1) or out (0) of stabilization.
+  //
+  int64_t rephased[2];
+
+  // Current elimination bound per eliminated variable.
+  //
+  int64_t elimbound;
+
+  struct {
+    int check;             // countdown to next terminator call
+    int forced;            // forced termination for testing
+  } terminate;
+
+  Limit ();
+};
+
+struct Last {
+  struct { int64_t propagations; } transred, vivify;
+  struct { int64_t fixed, subsumephases, marked; } elim;
+  struct { int64_t propagations, reductions; } probe;
+  struct { int64_t conflicts; } reduce, rephase;
+  struct { int64_t marked; } ternary;
+  struct { int64_t fixed; } collect;
+  Last ();
+};
+
+struct Inc {
+  int64_t flush;           // flushing interval in terms of conflicts
+  int64_t stabilize;       // stabilization interval increment
+  int64_t conflicts;       // next conflict limit if non-negative
+  int64_t decisions;       // next decision limit if non-negative
+  int64_t preprocessing;   // next preprocessing limit if non-negative
+  int64_t localsearch;     // next local search limit if non-negative
+  Inc ();
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/logging.cpp b/hCaD_V2/src/logging.cpp
new file mode 100644
index 0000000..59d3df3
--- /dev/null
+++ b/hCaD_V2/src/logging.cpp
@@ -0,0 +1,133 @@
+#ifdef LOGGING
+
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Logger::print_log_prefix (Internal * internal) {
+  internal->print_prefix ();
+  tout.magenta ();
+  fputs ("LOG ", stdout);
+  tout.magenta (true);
+  printf ("%d ", internal->level);
+  tout.normal ();
+}
+
+void Logger::log_empty_line (Internal * internal) {
+  internal->print_prefix ();
+  tout.magenta ();
+  const int len = internal->prefix.size (), max = 78 - len;
+  for (int i = 0; i < max; i++)
+    fputc ('-', stdout);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+void Logger::log (Internal * internal, const char * fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// It is hard to factor out the common part between the two clause loggers,
+// since they are also used in slightly different contexts.  Our attempt to
+// do so were not more readable than the current version.  See the header
+// for an explanation of the difference between the following two functions.
+
+void Logger::log (Internal * internal,
+                  const Clause * c, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (c) {
+    if (c->redundant) printf (" glue %d redundant", c->glue);
+    else printf (" irredundant");
+    printf (" size %d clause[%" PRId64 "]", c->size, c->id);
+    if (c->moved) printf (" ... (moved)");
+    else {
+      if (internal->opts.logsort) {
+        vector<int> s;
+        for (const auto & lit : *c)
+          s.push_back (lit);
+        sort (s.begin (), s.end (), clause_lit_less_than ());
+        for (const auto & lit : s)
+          printf (" %d", lit);
+      } else {
+        for (const auto & lit : *c)
+          printf (" %d", lit);
+      }
+    }
+  } else if (internal->level) printf (" decision");
+  else printf (" unit");
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// Same as above, but for the global clause 'c' (which is not a reason).
+
+void Logger::log (Internal * internal,
+                  const vector<int> & c, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (internal->opts.logsort) {
+    vector<int> s;
+    for (const auto & lit : c)
+      s.push_back (lit);
+    sort (s.begin (), s.end (), clause_lit_less_than ());
+    for (const auto & lit : s)
+      printf (" %d", lit);
+  } else {
+    for (const auto & lit : c)
+      printf (" %d", lit);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// Now for 'restore_clause' to avoid copying (without logging).
+
+void Logger::log (Internal * internal,
+                  const vector<int>::const_iterator & begin,
+                  const vector<int>::const_iterator & end,
+                  const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (internal->opts.logsort) {
+    vector<int> s;
+    for (auto p = begin; p != end; p++)
+      s.push_back (*p);
+    sort (s.begin (), s.end (), clause_lit_less_than ());
+    for (const auto & lit : s)
+      printf (" %d", lit);
+  } else {
+    for (auto p = begin; p != end; p++)
+      printf (" %d", *p);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+}
+
+#endif
diff --git a/hCaD_V2/src/logging.hpp b/hCaD_V2/src/logging.hpp
new file mode 100644
index 0000000..1012493
--- /dev/null
+++ b/hCaD_V2/src/logging.hpp
@@ -0,0 +1,79 @@
+#ifndef _logging_hpp_INCLUDED
+#define _logging_hpp_INCLUDED
+
+/*------------------------------------------------------------------------*/
+#ifdef LOGGING
+/*------------------------------------------------------------------------*/
+
+#include <vector>
+
+namespace CaDiCaL {
+
+// For debugging purposes and to help understanding what the solver is doing
+// there is a logging facility which is compiled in by './configure -l'.  It
+// still has to be enabled at run-time though (again using the '-l' option
+// in the stand-alone solver).  It produces quite a bit of information.
+
+using namespace std;
+
+struct Clause;
+struct Internal;
+
+struct Logger {
+
+static void print_log_prefix (Internal *);
+
+// Simple logging of a C-style format string.
+//
+static void log (Internal *, const char * fmt, ...)
+                 CADICAL_ATTRIBUTE_FORMAT (2, 3);
+
+// Prints the format string (with its argument) and then the clause.  The
+// clause can also be a zero pointer and then is interpreted as a decision
+// (current decision level > 0) or unit clause (zero decision level) and
+// printed accordingly.
+//
+static void log (Internal *, const Clause *, const char *fmt, ...)
+                 CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+// Same as before, except that this is meant for the global 'clause' stack
+// used for new clauses (and not for reasons).
+//
+static void log (Internal *, const vector<int> &, const char *fmt, ...)
+                 CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+// Another variant, to avoid copying (without logging).
+//
+static void log (Internal *,
+                 const vector<int>::const_iterator & begin,
+                 const vector<int>::const_iterator & end,
+                 const char *fmt, ...)
+                 CADICAL_ATTRIBUTE_FORMAT (4, 5);
+
+static void log_empty_line (Internal *);
+
+};
+
+}
+
+/*------------------------------------------------------------------------*/
+
+// Make sure that 'logging' code is really not included (second case of the
+// '#ifdef') if logging code is not included.
+
+#define LOG(...) \
+do { \
+  if (!internal->opts.log) break; \
+  Logger::log (internal, __VA_ARGS__); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+#else   // end of 'then' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+
+#define LOG(...) do { } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif // end of 'else' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+#endif
diff --git a/hCaD_V2/src/lookahead.cpp b/hCaD_V2/src/lookahead.cpp
new file mode 100644
index 0000000..9e8a16b
--- /dev/null
+++ b/hCaD_V2/src/lookahead.cpp
@@ -0,0 +1,504 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+struct literal_occ {
+  int lit;
+  int count;
+  bool operator<(const literal_occ &locc) const {
+    return (count > locc.count) || (count == locc.count && lit < locc.lit);
+
+  }
+  literal_occ operator++() {
+    ++count;
+    return *this;
+
+  }
+
+};
+
+std::vector<int> Internal::lookahead_populate_locc() {
+  std::vector<literal_occ> loccs((std::size_t)max_var+1);
+  for (std::size_t lit = 0; lit < loccs.size(); ++lit) {
+    loccs[lit].lit = lit;
+  }
+  for (const auto &c : clauses)
+    if (!c->redundant)
+      for (const auto &lit : *c)
+        if (active(lit))
+          ++loccs[std::abs(lit)];
+  std::sort(begin(loccs), end(loccs));
+  std::vector<int> locc_map;
+  locc_map.reserve(max_var);
+  for (const auto &locc : loccs)
+    locc_map.push_back(locc.lit);
+  return locc_map;
+
+}
+
+int Internal::lookahead_locc(const std::vector<int> &loccs) {
+  for (auto lit : loccs)
+    if (active(abs(lit)) && !assumed(lit) && !assumed(-lit) && !val(lit))
+      return lit;
+  return 0;
+
+  }
+
+  // This calculates the literal that appears the most often reusing the
+  // available datastructures and iterating over the clause set. This is too
+  // slow to be called iteratively. A faster (but inexact) version is
+  // lookahead_populate_loc and lookahead_loc.
+int Internal::most_occurring_literal () {
+  init_noccs ();
+  for (const auto & c : clauses)
+    if (!c->redundant)
+      for (const auto & lit : *c)
+        if (active (lit))
+          noccs (lit)++;
+  int64_t max_noccs = 0;
+  int res = 0;
+
+  if(unsat)
+    return INT_MIN;
+
+  propagate();
+  for (int idx = 1; idx <= max_var; idx++) {
+    if (!active (idx) || assumed(idx) || assumed(-idx) || val(idx)) continue;
+    for (int sign = -1; sign <= 1; sign += 2) {
+      const int lit = sign * idx;
+      if (!active(lit))
+        continue;
+      int64_t tmp = noccs(lit);
+      if (tmp <= max_noccs)
+        continue;
+      max_noccs = tmp;
+      res = lit;
+    }
+  }
+  MSG ("maximum occurrence %" PRId64 " of literal %d", max_noccs, res);
+  reset_noccs ();
+  return res;
+}
+
+// We probe on literals first, which occur more often negated and thus we
+// sort the 'probes' stack in such a way that literals which occur negated
+// less frequently come first.  Probes are taken from the back of the stack.
+
+struct probe_negated_noccs_rank {
+  Internal * internal;
+  probe_negated_noccs_rank (Internal * i) : internal (i) { }
+  typedef size_t Type;
+  Type operator () (int a) const { return internal->noccs (-a); }
+};
+
+// Follow the ideas in 'generate_probes' but flush non root probes and
+// reorder remaining probes.
+
+void Internal::lookahead_flush_probes () {
+
+  assert (!probes.empty ());
+
+  init_noccs ();
+  for (const auto & c : clauses) {
+    int a, b;
+    if (!is_binary_clause (c, a, b)) continue;
+    noccs (a)++;
+    noccs (b)++;
+  }
+
+  const auto eop = probes.end ();
+  auto j = probes.begin ();
+  for (auto i = j; i != eop; i++) {
+    int lit = *i;
+    if (!active (lit)) continue;
+    const bool have_pos_bin_occs = noccs (lit) > 0;
+    const bool have_neg_bin_occs = noccs (-lit) > 0;
+    if (have_pos_bin_occs == have_neg_bin_occs) continue;
+    if (have_pos_bin_occs) lit = -lit;
+    assert (!noccs (lit)), assert (noccs (-lit) > 0);
+    if (propfixed (lit) >= stats.all.fixed) continue;
+    MSG ("keeping probe %d negated occs %" PRId64 "", lit, noccs (-lit));
+    *j++ = lit;
+  }
+  size_t remain = j - probes.begin ();
+#ifndef QUIET
+  size_t flushed = probes.size () - remain;
+#endif
+  probes.resize (remain);
+
+  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
+
+  reset_noccs ();
+  shrink_vector (probes);
+
+  PHASE ("probe-round", stats.probingrounds,
+    "flushed %zd literals %.0f%% remaining %zd",
+    flushed, percent (flushed, remain + flushed), remain);
+}
+
+void Internal::lookahead_generate_probes () {
+
+  assert (probes.empty ());
+
+  // First determine all the literals which occur in binary clauses. It is
+  // way faster to go over the clauses once, instead of walking the watch
+  // lists for each literal.
+  //
+  init_noccs ();
+  for (const auto & c : clauses) {
+    int a, b;
+    if (!is_binary_clause (c, a, b)) continue;
+    noccs (a)++;
+    noccs (b)++;
+  }
+
+  for (int idx = 1; idx <= max_var; idx++) {
+
+    // Then focus on roots of the binary implication graph, which are
+    // literals occurring negatively in a binary clause, but not positively.
+    // If neither 'idx' nor '-idx' is a root it makes less sense to probe
+    // this variable.
+
+    // This argument requires that equivalent literal substitution through
+    // 'decompose' is performed, because otherwise there might be 'cyclic
+    // roots' which are not tried, i.e., -1 2 0, 1 -2 0, 1 2 3 0, 1 2 -3 0.
+
+    const bool have_pos_bin_occs = noccs (idx) > 0;
+    const bool have_neg_bin_occs = noccs (-idx) > 0;
+
+    // if (have_pos_bin_occs == have_neg_bin_occs) continue;
+
+    if (have_pos_bin_occs) {
+      int probe = -idx;
+
+      // See the discussion where 'propfixed' is used below.
+      //
+      if (propfixed (probe) >= stats.all.fixed) continue;
+
+      MSG ("scheduling probe %d negated occs %" PRId64 "", probe, noccs (-probe));
+      probes.push_back (probe);
+    }
+
+    if (have_neg_bin_occs) {
+      int probe = idx;
+
+      // See the discussion where 'propfixed' is used below.
+      //
+      if (propfixed (probe) >= stats.all.fixed) continue;
+
+      MSG ("scheduling probe %d negated occs %" PRId64 "",
+           probe, noccs (-probe));
+      probes.push_back (probe);
+    }
+  }
+
+  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
+
+  reset_noccs ();
+  shrink_vector (probes);
+
+  PHASE ("probe-round", stats.probingrounds,
+    "scheduled %zd literals %.0f%%",
+    probes.size (), percent (probes.size (), 2*max_var));
+}
+
+int Internal::lookahead_next_probe () {
+
+  int generated = 0;
+
+  for (;;) {
+
+    if (probes.empty ()) {
+      if (generated++) return 0;
+      lookahead_generate_probes ();
+    }
+
+    while (!probes.empty ()) {
+
+      int probe = probes.back ();
+      probes.pop_back ();
+
+      // Eliminated or assigned.
+      //
+      if (!active (probe) || assumed(probe) || assumed (-probe)) continue;
+
+      // There is now new unit since the last time we propagated this probe,
+      // thus we propagated it before without obtaining a conflict and
+      // nothing changed since then.  Thus there is no need to propagate it
+      // again.  This observation was independently made by Partik Simons
+      // et.al. in the context of implementing 'smodels' (see for instance
+      // Alg. 4 in his JAIR article from 2002) and it has also been
+      // contributed to the thesis work of Yacine Boufkhad.
+      //
+      if (propfixed (probe) >= stats.all.fixed) continue;
+
+      return probe;
+    }
+  }
+}
+
+bool non_tautological_cube (std::vector<int> cube) {
+  std::sort(begin(cube), end(cube), clause_lit_less_than ());
+
+  for(size_t i = 0, j = 1; j < cube.size(); ++i, ++j)
+    if(cube[i] == cube[j])
+      return false;
+    else if (cube[i] == - cube[j])
+      return false;
+    else if (cube[i] == 0)
+      return false;
+
+  return true;
+
+}
+
+bool Internal::terminating_asked() {
+
+  if (external->terminator && external->terminator->terminate()) {
+    MSG("connected terminator forces termination");
+    return true;
+  }
+
+  if (termination_forced) {
+    MSG("termination forced");
+    return true;
+  }
+  return false;
+}
+
+// We run probing on all literals with some differences:
+//
+// * no limit on the number of propagations. We rely on terminating to stop()
+// * we run only one round
+//
+// The run can be expensive, so we actually first run the cheaper
+// occurrence version and only then run lookahead.
+//
+int Internal::lookahead_probing() {
+
+  if (!active ())
+    return 0;
+
+  MSG ("lookahead-probe-round %" PRId64
+       " without propagations limit and %zu assumptions",
+       stats.probingrounds, assumptions.size());
+
+  termination_forced = false;
+
+#ifndef QUIET
+  int old_failed = stats.failed;
+  int64_t old_probed = stats.probed;
+#endif
+  int64_t old_hbrs = stats.hbrs;
+
+  if (unsat) return INT_MIN;
+  if (level) backtrack ();
+  if (!propagate ()) {
+    MSG ("empty clause before probing");
+    learn_empty_clause ();
+    return INT_MIN;
+  }
+
+  if (terminating_asked())
+    return most_occurring_literal();
+
+  decompose ();
+
+  if (ternary ())       // If we derived a binary clause
+    decompose ();       // then start another round of ELS.
+
+  // Remove duplicated binary clauses and perform in essence hyper unary
+  // resolution, i.e., derive the unit '2' from '1 2' and '-1 2'.
+  //
+  mark_duplicated_binary_clauses_as_garbage ();
+
+  lim.conflicts = -1;
+
+  if (!probes.empty ()) lookahead_flush_probes ();
+
+  // We reset 'propfixed' since there was at least another conflict thus
+  // a new learned clause, which might produce new propagations (and hyper
+  // binary resolvents).  During 'generate_probes' we keep the old value.
+  //
+  for (int idx = 1; idx <= max_var; idx++)
+    propfixed (idx) = propfixed (-idx) = -1;
+
+  assert (unsat || propagated == trail.size ());
+  propagated = propagated2 = trail.size ();
+
+  int probe;
+  int res = most_occurring_literal();
+  int max_hbrs = -1;
+
+  set_mode (PROBE);
+
+  MSG("unsat = %d, terminating_asked () = %d ", unsat, terminating_asked ());
+  while (!unsat &&
+         !terminating_asked () &&
+         (probe = lookahead_next_probe ())) {
+    stats.probed++;
+    int hbrs;
+
+    probe_assign_decision (probe);
+    if (probe_propagate ())
+      hbrs = trail.size(), backtrack();
+    else hbrs = 0, failed_literal (probe);
+    if (max_hbrs < hbrs ||
+        (max_hbrs == hbrs &&
+         internal->bumped(probe) > internal->bumped(res))) {
+      res = probe;
+      max_hbrs = hbrs;
+    }
+  }
+
+  reset_mode (PROBE);
+
+  if (unsat) {
+    MSG ("probing derived empty clause");
+    res = INT_MIN;
+  }
+  else if (propagated < trail.size ()) {
+    MSG ("probing produced %zd units",
+         (size_t)(trail.size () - propagated));
+    if (!propagate ()) {
+      MSG ("propagating units after probing results in empty clause");
+      learn_empty_clause ();
+      res = INT_MIN;
+    } else sort_watches ();
+  }
+
+#ifndef QUIET
+  int failed = stats.failed - old_failed;
+  int64_t probed = stats.probed - old_probed;
+#endif
+  int64_t hbrs = stats.hbrs - old_hbrs;
+
+  MSG ("lookahead-probe-round %" PRId64 " probed %" PRId64
+       " and found %d failed literals",
+       stats.probingrounds,
+       probed, failed);
+
+  if (hbrs)
+    PHASE ("lookahead-probe-round", stats.probingrounds,
+      "found %" PRId64 " hyper binary resolvents", hbrs);
+
+  MSG ("lookahead literal %d with %d\n", res, max_hbrs);
+
+  return res;
+}
+
+CubesWithStatus Internal::generate_cubes(int depth, int min_depth) {
+  if (!active() || depth == 0) {
+    CubesWithStatus cubes;
+    cubes.cubes.push_back(std::vector<int>());
+    return cubes;
+  }
+
+  lookingahead = true;
+  START(lookahead);
+  MSG("Generating cubes of depth %i", depth);
+
+  // presimplify required due to assumptions
+
+  termination_forced = false;
+  int res = already_solved();
+  if (res == 0)
+   res = restore_clauses();
+  if(unsat)
+    res = 10;
+  if (res != 0)
+    res = solve(true);
+  if (res != 0) {
+    MSG("Solved during preprocessing");
+    CubesWithStatus cubes;
+    cubes.status = res;
+    cubes.status = 20;
+    lookingahead = false;
+    STOP(lookahead);
+    return cubes;
+  }
+
+  reset_limits();
+  MSG ("generate cubes with %zu assumptions\n", assumptions.size());
+
+  assert(ntab.empty());
+  std::vector<int> current_assumptions{assumptions};
+  std::vector<std::vector<int>> cubes {{assumptions}};
+  auto loccs{lookahead_populate_locc()};
+  LOG("loccs populated\n");
+  assert(ntab.empty());
+
+  for (int i = 0; i < depth; ++i) {
+    LOG("Probing at depth %i, currently %zu have been generated",
+        i, cubes.size());
+    std::vector<std::vector<int>> cubes2 {std::move(cubes)};
+    cubes.clear ();
+
+    for (size_t j = 0; j < cubes2.size(); ++j) {
+      assert(ntab.empty());
+      assert(!unsat);
+      reset_assumptions();
+      for (auto lit : cubes2[j])
+        assume(lit);
+      restore_clauses();
+      propagate();
+        // preprocess_round(0); //uncomment maybe
+
+      if (unsat) {
+        LOG("current cube is unsat; skipping");
+        unsat = false;
+        continue;
+      }
+
+      int res = terminating_asked()  ? lookahead_locc(loccs) : lookahead_probing();
+      if(unsat) {
+        LOG("current cube is unsat; skipping");
+        unsat = false;
+        continue;
+      }
+
+      if (res == 0) {
+        LOG("no lit to split %i", res);
+        cubes.push_back(cubes2[j]);
+        continue;
+      }
+
+      assert(res != 0);
+      LOG("splitting on lit %i", res);
+      std::vector<int> cube1{cubes2[j]};
+      cube1.push_back(res);
+      std::vector<int> cube2{std::move(cubes2[j])};
+      cube2.push_back(-res);
+      cubes.push_back(cube1);
+      cubes.push_back(cube2);
+    }
+
+    if (terminating_asked() && i >= min_depth)
+      break;
+  }
+
+  assert(std::for_each(std::begin(cubes), std::end(cubes), [](std::vector<int> cube){return non_tautological_cube (cube);}));
+  reset_assumptions();
+
+  for(auto lit : current_assumptions)
+    assume(lit);
+
+  STOP(lookahead);
+  lookingahead = false;
+
+  if (unsat) {
+    LOG("Solved during preprocessing");
+    CubesWithStatus cubes;
+    cubes.status = 20;
+    cubes.status = res;
+    return cubes;
+  }
+
+  CubesWithStatus rcubes;
+  rcubes.status = 0;
+  rcubes.cubes = cubes;
+
+  return rcubes;
+}
+
+} // namespace CaDiCaL
diff --git a/hCaD_V2/src/lucky.cpp b/hCaD_V2/src/lucky.cpp
new file mode 100644
index 0000000..25f34cd
--- /dev/null
+++ b/hCaD_V2/src/lucky.cpp
@@ -0,0 +1,307 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// It turns out that even in the competition there are formulas which are
+// easy to satisfy by either setting all variables to the same truth value
+// or by assigning variables to the same value and propagating it.  In the
+// latter situation this can be done either in the order of all variables
+// (forward or backward) or in the order of all clauses.  These lucky
+// assignments can be tested initially in a kind of pre-solving step.
+
+// This function factors out clean up code common among the 'lucky'
+// functions for backtracking and resetting a potential conflict.  One could
+// also use exceptions here, but there are two different reasons for
+// aborting early.  The first kind of aborting is due to asynchronous
+// termination and the second kind due to a situation in which it is clear
+// that a particular function will not be successful (for instance a
+// completely negative clause is found).  The latter situation returns zero
+// and will just abort the particular lucky function, while the former will
+// abort all (by returning '-1').
+
+int Internal::unlucky (int res) {
+  if (level > 0) backtrack ();
+  if (conflict) conflict = 0;
+  return res;
+}
+
+int Internal::trivially_false_satisfiable () {
+  LOG ("checking that all clauses contain a negative literal");
+  assert (!level);
+  assert (assumptions.empty ());
+  for (const auto & c : clauses) {
+    if (terminated_asynchronously (100)) return unlucky (-1);
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+    bool satisfied = false, found_negative_literal = false;
+    for (const auto & lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) { satisfied = true; break; }
+      if (tmp < 0) continue;
+      if (lit > 0) continue;
+      found_negative_literal = true;
+      break;
+    }
+    if (satisfied || found_negative_literal) continue;
+    LOG (c, "found purely positively");
+    return unlucky (0);
+  }
+  VERBOSE (1, "all clauses contain a negative literal");
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (-idx);
+    if (propagate ()) continue;
+    assert (level > 0);
+    LOG ("propagation failed including redundant clauses");
+    return unlucky (0);
+  }
+  stats.lucky.constant.zero++;
+  return 10;
+}
+
+int Internal::trivially_true_satisfiable () {
+  LOG ("checking that all clauses contain a positive literal");
+  assert (!level);
+  assert (assumptions.empty ());
+  for (const auto & c : clauses) {
+    if (terminated_asynchronously (100)) return unlucky (-1);
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+    bool satisfied = false, found_positive_literal = false;
+    for (const auto & lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) { satisfied = true; break; }
+      if (tmp < 0) continue;
+      if (lit < 0) continue;
+      found_positive_literal = true;
+      break;
+    }
+    if (satisfied || found_positive_literal) continue;
+    LOG (c, "found purely negatively");
+    return unlucky (0);
+  }
+  VERBOSE (1, "all clauses contain a positive literal");
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (idx);
+    if (propagate ()) continue;
+    assert (level > 0);
+    LOG ("propagation failed including redundant clauses");
+    return unlucky (0);
+  }
+  stats.lucky.constant.one++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::forward_false_satisfiable () {
+  LOG ("checking increasing variable index false assignment");
+  assert (!unsat);
+  assert (!level);
+  assert (assumptions.empty ());
+  for (auto idx : vars) {
+    if (terminated_asynchronously (100)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (-idx);
+    if (!propagate ()) return unlucky (0);
+  }
+  VERBOSE (1, "forward assuming variables false satisfies formula");
+  assert (satisfied ());
+  stats.lucky.forward.zero++;
+  return 10;
+}
+
+int Internal::forward_true_satisfiable () {
+  LOG ("checking increasing variable index true assignment");
+  assert (!unsat);
+  assert (!level);
+  assert (assumptions.empty ());
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (idx);
+    if (!propagate ()) return unlucky (0);
+  }
+  VERBOSE (1, "forward assuming variables true satisfies formula");
+  assert (satisfied ());
+  stats.lucky.forward.one++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::backward_false_satisfiable () {
+  LOG ("checking decreasing variable index false assignment");
+  assert (!unsat);
+  assert (!level);
+  assert (assumptions.empty ());
+  for (int idx = max_var; idx > 0; idx--) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (-idx);
+    if (!propagate ()) return unlucky (0);
+  }
+  VERBOSE (1, "backward assuming variables false satisfies formula");
+  assert (satisfied ());
+  stats.lucky.backward.zero++;
+  return 10;
+}
+
+int Internal::backward_true_satisfiable () {
+  LOG ("checking decreasing variable index true assignment");
+  assert (!unsat);
+  assert (!level);
+  assert (assumptions.empty ());
+  for (int idx = max_var; idx > 0; idx--) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (idx);
+    if (!propagate ()) return unlucky (0);
+  }
+  VERBOSE (1, "backward assuming variables true satisfies formula");
+  assert (satisfied ());
+  stats.lucky.backward.one++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The following two functions test if the formula is a satisfiable horn
+// formula.  Actually the test is slightly more general.  It goes over all
+// clauses and assigns the first positive literal to true and propagates.
+// Already satisfied clauses are of course skipped.  A reverse function
+// is not implemented yet.
+
+int Internal::positive_horn_satisfiable () {
+  LOG ("checking that all clauses are positive horn satisfiable");
+  assert (!level);
+  assert (assumptions.empty ());
+  for (const auto & c : clauses) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+    int positive_literal = 0;
+    bool satisfied = false;
+    for (const auto & lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) { satisfied = true; break; }
+      if (tmp < 0) continue;
+      if (lit < 0) continue;
+      positive_literal = lit;
+      break;
+    }
+    if (satisfied) continue;
+    if (!positive_literal) {
+      LOG (c, "no positive unassigned literal in");
+      return unlucky (0);
+    }
+    assert (positive_literal > 0);
+    LOG (c, "found positive literal %d in", positive_literal);
+    search_assume_decision (positive_literal);
+    if (propagate ()) continue;
+    LOG ("propagation of positive literal %d leads to conflict",
+      positive_literal);
+    return unlucky (0);
+  }
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (-idx);
+    if (propagate ()) continue;
+    LOG ("propagation of remaining literal %d leads to conflict", -idx);
+    return unlucky (0);
+  }
+  VERBOSE (1, "clauses are positive horn satisfied");
+  assert (!conflict);
+  assert (satisfied ());
+  stats.lucky.horn.positive++;
+  return 10;
+}
+
+int Internal::negative_horn_satisfiable () {
+  LOG ("checking that all clauses are negative horn satisfiable");
+  assert (!level);
+  assert (assumptions.empty ());
+  for (const auto & c : clauses) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (c->garbage) continue;
+    if (c->redundant) continue;
+    int negative_literal = 0;
+    bool satisfied = false;
+    for (const auto & lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) { satisfied = true; break; }
+      if (tmp < 0) continue;
+      if (lit > 0) continue;
+      negative_literal = lit;
+      break;
+    }
+    if (satisfied) continue;
+    if (!negative_literal) {
+      if (level > 0) backtrack ();
+      LOG (c, "no negative unassigned literal in");
+      return unlucky (0);
+    }
+    assert (negative_literal < 0);
+    LOG (c, "found negative literal %d in", negative_literal);
+    search_assume_decision (negative_literal);
+    if (propagate ()) continue;
+    LOG ("propagation of negative literal %d leads to conflict",
+      negative_literal);
+    return unlucky (0);
+  }
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10)) return unlucky (-1);
+    if (val (idx)) continue;
+    search_assume_decision (idx);
+    if (propagate ()) continue;
+    LOG ("propagation of remaining literal %d leads to conflict", idx);
+    return unlucky (0);
+  }
+  VERBOSE (1, "clauses are negative horn satisfied");
+  assert (!conflict);
+  assert (satisfied ());
+  stats.lucky.horn.negative++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::lucky_phases () {
+  assert (!level);
+  require_mode (SEARCH);
+  if (!opts.lucky) return 0;
+
+  // TODO: Some of the lucky assignments can also be found if there are
+  // assumptions, but this is not completely implemented nor tested yet.
+  //
+  if (!assumptions.empty ()) return 0;
+
+  START (search);
+  START (lucky);
+  assert (!searching_lucky_phases);
+  searching_lucky_phases = true;
+  stats.lucky.tried++;
+  int res       = trivially_false_satisfiable ();
+  if (!res) res = trivially_true_satisfiable ();
+  if (!res) res = forward_true_satisfiable ();
+  if (!res) res = forward_false_satisfiable ();
+  if (!res) res = backward_false_satisfiable ();
+  if (!res) res = backward_true_satisfiable ();
+  if (!res) res = positive_horn_satisfiable ();
+  if (!res) res = negative_horn_satisfiable ();
+  if (res < 0) assert (termination_forced), res = 0;
+  if (res == 10) stats.lucky.succeeded++;
+  report ('l', !res);
+  assert (searching_lucky_phases);
+  searching_lucky_phases = false;
+  STOP (lucky);
+  STOP (search);
+
+  return res;
+}
+
+}
diff --git a/hCaD_V2/src/makefile b/hCaD_V2/src/makefile
new file mode 120000
index 0000000..f992a78
--- /dev/null
+++ b/hCaD_V2/src/makefile
@@ -0,0 +1 @@
+/home/chenzh/experiments/cec/equal/hCaD_V2/makefile
\ No newline at end of file
diff --git a/hCaD_V2/src/message.cpp b/hCaD_V2/src/message.cpp
new file mode 100644
index 0000000..651d098
--- /dev/null
+++ b/hCaD_V2/src/message.cpp
@@ -0,0 +1,206 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+#ifndef QUIET
+/*------------------------------------------------------------------------*/
+
+void Internal::print_prefix () { fputs (prefix.c_str (), stdout); }
+
+void Internal::vmessage (const char * fmt, va_list & ap) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet) return;
+  print_prefix ();
+  vprintf (fmt, ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+void Internal::message (const char * fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  vmessage (fmt, ap);
+  va_end (ap);
+}
+
+void Internal::message () {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet) return;
+  print_prefix ();
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::vverbose (int level, const char * fmt, va_list & ap) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet || level > opts.verbose) return;
+  print_prefix ();
+  vprintf (fmt, ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+void Internal::verbose (int level, const char * fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  vverbose (level, fmt, ap);
+  va_end (ap);
+}
+
+void Internal::verbose (int level) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet || level > opts.verbose) return;
+  print_prefix ();
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::section (const char * title) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet) return;
+  if (stats.sections++) MSG ();
+  print_prefix ();
+  tout.blue ();
+  fputs ("--- [ ", stdout);
+  tout.blue (true);
+  fputs (title, stdout);
+  tout.blue ();
+  fputs (" ] ", stdout);
+  for (int i = strlen (title) + strlen (prefix.c_str ()) + 9; i < 78; i++)
+    fputc ('-' , stdout);
+  tout.normal ();
+  fputc ('\n', stdout);
+  MSG ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::phase (const char * phase, const char * fmt, ...) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet ||
+      (!force_phase_messages && opts.verbose < 2)) return;
+  print_prefix ();
+  printf ("[%s] ", phase);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+void Internal::phase (const char * phase,
+                      int64_t count, const char * fmt, ...) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet ||
+      (!force_phase_messages && opts.verbose < 2)) return;
+  print_prefix ();
+  printf ("[%s-%" PRId64 "] ", phase, count);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+#endif // ifndef QUIET
+/*------------------------------------------------------------------------*/
+
+void Internal::warning (const char *fmt, ...) {
+  fflush (stdout);
+  terr.bold ();
+  fputs ("cadical: ", stderr);
+  terr.red (1);
+  fputs ("warning:", stderr);
+  terr.normal ();
+  fputc (' ', stderr);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::error_message_start () {
+  fflush (stdout);
+  terr.bold ();
+  fputs ("cadical: ", stderr);
+  terr.red (1);
+  fputs ("error:", stderr);
+  terr.normal ();
+  fputc (' ', stderr);
+}
+
+void Internal::error_message_end () {
+  fputc ('\n', stderr);
+  fflush (stderr);
+  // TODO add possibility to use call back instead.
+  exit (1);
+}
+
+void Internal::verror (const char *fmt, va_list & ap) {
+  error_message_start ();
+  vfprintf (stderr, fmt, ap);
+  error_message_end ();
+}
+
+void Internal::error (const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  verror (fmt, ap);
+  va_end (ap);                          // unreachable
+}
+
+/*------------------------------------------------------------------------*/
+
+void fatal_message_start () {
+  fflush (stdout);
+  terr.bold ();
+  fputs ("cadical: ", stderr);
+  terr.red (1);
+  fputs ("fatal error:", stderr);
+  terr.normal ();
+  fputc (' ', stderr);
+}
+
+void fatal_message_end () {
+  fputc ('\n', stderr);
+  fflush (stderr);
+  abort ();
+}
+
+void fatal (const char *fmt, ...) {
+  fatal_message_start ();
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fatal_message_end ();
+  abort ();
+}
+
+}
diff --git a/hCaD_V2/src/message.hpp b/hCaD_V2/src/message.hpp
new file mode 100644
index 0000000..162187f
--- /dev/null
+++ b/hCaD_V2/src/message.hpp
@@ -0,0 +1,40 @@
+#ifndef _message_h_INCLUDED
+#define _message_h_INCLUDED
+
+/*------------------------------------------------------------------------*/
+
+// Macros for compact message code.
+
+#ifndef QUIET
+
+#define LINE() \
+do { if (internal) internal->message (); } while (0)
+
+#define MSG(...) \
+do { if (internal) internal->message (__VA_ARGS__); } while (0)
+
+#define PHASE(...) \
+do { if (internal) internal->phase (__VA_ARGS__); } while (0)
+
+#define SECTION(...) \
+do { if (internal) internal->section (__VA_ARGS__); } while (0)
+
+#define VERBOSE(...) \
+do { if (internal) internal->verbose (__VA_ARGS__); } while (0)
+
+#else
+
+#define LINE() do { } while (0)
+#define MSG(...) do { } while (0)
+#define PHASE(...) do { } while (0)
+#define SECTION(...) do { } while (0)
+#define VERBOSE(...) do { } while (0)
+
+#endif
+
+#define FATAL fatal
+#define WARNING(...) internal->warning (__VA_ARGS__)
+
+/*------------------------------------------------------------------------*/
+
+#endif // ifndef _message_h_INCLUDED
diff --git a/hCaD_V2/src/minimize.cpp b/hCaD_V2/src/minimize.cpp
new file mode 100644
index 0000000..2495129
--- /dev/null
+++ b/hCaD_V2/src/minimize.cpp
@@ -0,0 +1,104 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Functions for learned clause minimization. We only have the recursive
+// version, which actually really is implemented recursively.  We also
+// played with a derecursified version, which however was more complex and
+// slower.  The trick to keep potential stack exhausting recursion under
+// guards is to explicitly limit the recursion depth.
+
+// Instead of signatures as in the original implementation in MiniSAT and
+// our corresponding paper, we use the 'poison' idea of Allen Van Gelder to
+// mark unsuccessful removal attempts, then Donald Knuth's idea to abort
+// minimization if only one literal was seen on the level and a new idea of
+// also aborting if the earliest seen literal was assigned afterwards.
+
+bool Internal::minimize_literal (int lit, int depth) {
+  LOG("attempt to minimize lit %d at depth %d", lit, depth);
+  assert(val(lit) > 0);
+  Flags & f = flags (lit);
+  Var & v = var (lit);
+  if (!v.level || f.removable || f.keep) return true;
+  if (!v.reason || f.poison || v.level == level) return false;
+  const Level & l = control[v.level];
+  if (!depth && l.seen.count < 2) return false;   // Don Knuth's idea
+  if (v.trail <= l.seen.trail) return false;      // new early abort
+  if (depth > opts.minimizedepth) return false;
+  bool res = true;
+  assert (v.reason);
+  const const_literal_iterator end = v.reason->end ();
+  const_literal_iterator i;
+  for (i = v.reason->begin (); res && i != end; i++) {
+    const int other = *i;
+    if (other == lit) continue;
+    res = minimize_literal (-other, depth + 1);
+  }
+  if (res) f.removable = true; else f.poison = true;
+  minimized.push_back (lit);
+  if (!depth) LOG ("minimizing %d %s", lit, res ? "succeeded" : "failed");
+  return res;
+}
+
+// Sorting the clause before minimization with respect to the trail order
+// (literals with smaller trail height first) is necessary but natural and
+// might help to minimize the required recursion depth too.
+
+struct minimize_trail_positive_rank {
+  Internal * internal;
+  minimize_trail_positive_rank (Internal * s) : internal (s) { }
+  typedef int Type;
+  Type operator () (const int & a) const {
+    assert (internal->val (a));
+    return internal->var (a).trail;
+  }
+};
+
+struct minimize_trail_smaller {
+  Internal * internal;
+  minimize_trail_smaller (Internal * s) : internal (s) { }
+  bool operator () (const int & a, const int & b) const {
+    return internal->var (a).trail < internal->var (b).trail;
+  }
+};
+
+void Internal::minimize_clause () {
+  START (minimize);
+  LOG (clause, "minimizing first UIP clause");
+
+  external->check_learned_clause (); // check 1st UIP learned clause first
+  minimize_sort_clause();
+
+  assert (minimized.empty ());
+  const auto end = clause.end ();
+  auto j = clause.begin (), i = j;
+  for (; i != end; i++)
+    if (minimize_literal (-*i)) stats.minimized++;
+    else flags (*j++ = *i).keep = true;
+  LOG ("minimized %zd literals", (size_t)(clause.end () - j));
+  if (j != end) clause.resize (j - clause.begin ());
+  clear_minimized_literals ();
+  STOP (minimize);
+}
+
+// Sort the literals in reverse assignment order (thus trail order) to
+// establish the base case of the recursive minimization algorithm in the
+// positive case (where a literal with 'keep' true is hit).
+//
+void Internal::minimize_sort_clause () {
+  MSORT(opts.radixsortlim, clause.begin(), clause.end(),
+        minimize_trail_positive_rank(this), minimize_trail_smaller(this));
+}
+
+void Internal::clear_minimized_literals () {
+  LOG ("clearing %zd minimized literals", minimized.size ());
+  for (const auto & lit : minimized) {
+    Flags & f = flags (lit);
+    f.poison = f.removable = f.shrinkable = false;
+  }
+  for (const auto & lit : clause)
+    assert(!flags(lit).shrinkable), flags(lit).keep = flags(lit).shrinkable = false;
+  minimized.clear ();
+}
+
+}
diff --git a/hCaD_V2/src/mobical.cpp b/hCaD_V2/src/mobical.cpp
new file mode 100644
index 0000000..9b373b1
--- /dev/null
+++ b/hCaD_V2/src/mobical.cpp
@@ -0,0 +1,3082 @@
+/*------------------------------------------------------------------------*/
+/* Copyright (C) 2018-2021, Armin Biere, Johannes Kepler University Linz  */
+/* Copyright (C) 2020, Mathias Fleury, Johannes Kepler University Linz    */
+/*------------------------------------------------------------------------*/
+
+// Model Based Tester for the CaDiCaL SAT Solver Library.
+
+namespace CaDiCaL {
+
+static const char * USAGE =
+"usage: mobical [ <option> ... ] [ <mode> ]\n"
+"\n"
+"where '<option>' can be one of the following:\n"
+"\n"
+"  --help    | -h    print this command line option summary and exit\n"
+"  --version         print CaDiCaL's three character version and exit\n"
+"  --build           print build configuration\n"
+"\n"
+"  -v                increase verbosity\n"
+"  --colors          force colors for both '<stdout>' and '<stderr>'\n"
+"  --no-colors       disable colors if '<stderr>' is connected to terminal\n"
+"  --no-terminal     assume '<stderr>' is not connected to terminal\n"
+"  --no-seeds        do not print seeds in random mode\n"
+"\n"
+"  -<n>              specify the number of solving phases explicitly\n"
+"  --time <seconds>  set time limit per trace (none=0, default=%d)\n"
+"  --space <MB>      set space limit (none=0, default=%d)\n"
+"\n"
+"  --do-not-ignore-resource-limits  consider out-of-time or memory as error\n"
+"\n"
+"  --small           generate small formulas only\n"
+"  --medium          generate medium sized formulas only\n"
+"  --big             generate big formulas only\n"
+"\n"
+"Then '<mode>' is one of these\n"
+"\n"
+"  <seed>            generate and execute trace for given 64-bit seed\n"
+"  <seed>  <output>  generate trace, shrink and write it to file\n"
+"  <input> <output>  read trace, shrink and write it to output file\n"
+"  <input>           read and replay the specified input trace\n"
+"\n"
+"The output trace is not shrunken if it is not failing.  However,\n"
+"before it is written it is executed, unless '--do-not-execute'\n"
+"is specified:\n"
+"\n"
+"  --do-not-execute  just write to '<output>' without execution\n"
+"\n"
+"In order to check memory issues or collect coverage you can force\n"
+"execution within the main process, which however also means that\n"
+"the model based tester aborts as soon a test fails\n"
+"\n"
+"  --do-not-fork     execute all tests in main process directly\n"
+"\n"
+"In order to replay a trace which violates an API contract use\n"
+"\n"
+"  --do-not-enforce-contracts\n"
+"\n"
+"To read from '<stdin>' use '-' as '<input>' and also '-' instead of\n"
+"'<output>' to write to '<stdout>'.\n"
+"\n"
+#ifdef LOGGING
+"As the library is compiled with logging support ('-DLOGGING')\n"
+"one can force to add the 'set log 1' call to the trace with\n"
+"\n"
+"  --log | -l        force low-level logging for detailed debugging\n"
+"\n"
+#endif
+"Implicitly add 'dump' and 'stats' calls to traces:\n"
+"\n"
+"  --dump  | -d      force dumping the CNF before every 'solve'\n"
+"  --stats | -s      force printing statistics after every 'solve'\n"
+"\n"
+"Otherwise if no '<mode>' is specified the default is to generate\n"
+"random traces internally until the execution of a trace fails, which\n"
+"means it produces a non-zero exit code.  Then the trace is rerun and\n"
+"shrunken through delta-debugging to produce a smaller trace.  The\n"
+"shrunken failing trace is written as 'red-<seed>.trace' to the\n"
+"current working directory.\n"
+"\n"
+"The following options disable certain parts of the shrinking algorithm:\n"
+"\n"
+"  --do-not-shrink[-at-all]\n"
+"  --do-not-add-options[-before-shrinking]\n"
+"  --do-not-shrink-phases\n"
+"  --do-not-shrink-clauses\n"
+"  --do-not-shrink-literals\n"
+"  --do-not-shrink-basic[-calls]\n"
+"  --do-not-disable[-options]\n"
+"  --do-not-reduce[[-option]-values]\n"
+"  --do-not-shrink-variables\n"
+"  --do-not-shrink-options\n"
+"\n"
+"The standard mode of using the model based tester is to start it in\n"
+"random testing mode without '<input>', '<seed>' nor '<output>' option.\n"
+"If a failing trace is found it will be shrunken and the resulting trace\n"
+"written to the current working directory.  Then the model based tester\n"
+"can be interrupted and then called again with the produced failing trace\n"
+"as single argument.  This invocation will execute the trace within the\n"
+"same process and thus can directly be investigated with a symbolic\n"
+"debugger such as 'gdb' or maybe first checked for memory issues with\n"
+"'valgrind' or recompilation with memory checking '-fsanitize=address'.\n"
+;
+
+} // end of 'namespace CaDiCaL'.
+
+/*------------------------------------------------------------------------*/
+
+#include "internal.hpp"
+#include "signal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+#include <cstdarg>
+#include <cstring>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+/*------------------------------------------------------------------------*/
+
+extern "C" {
+#include <unistd.h>
+}
+
+/*------------------------------------------------------------------------*/
+namespace CaDiCaL {     // All except 'main' below.
+/*------------------------------------------------------------------------*/
+
+using namespace std;
+
+class Reader;
+class Trace;
+
+#define DEFAULT_TIME_LIMIT 10
+#define DEFAULT_SPACE_LIMIT 1024
+
+/*------------------------------------------------------------------------*/
+
+// Options to generate traces.
+
+enum Size { NOSIZE = 0, SMALL = 10, MEDIUM = 30, BIG = 50 };
+
+struct Force {
+  Size size;
+  int phases;
+  Force () : size (NOSIZE), phases (-1) { }
+};
+
+// Options to shrink traces.
+
+struct DoNot
+{
+  bool add;             // add all options before shrinking             'a'
+  struct {
+    bool atall;         // do not shrink anything                       's'
+    bool phases;        // shrink complete incremental solving phases   'p'
+    bool clauses;       // shrink full clauses                          'c'
+    bool literals;      // shrink literals which shrinks                'l'
+    bool basic;         // shrink other basic calls                     'b'
+    bool options;       // shrink option calls                          'o'
+  } shrink;
+  bool disable;         // try to eagerly disable all options           'd'
+  bool map;             // do not map variable indices                  'm'
+  bool reduce;          // reduce option values                         'r'
+  bool execute;         // do not execute trace
+  bool fork;            // do not fork sub-process
+  bool enforce;         // do not enforce contracts on read trace
+  bool seeds;
+  bool ignore_resource_limits;
+
+  DoNot ()
+  {
+    add = false;
+    shrink.atall = false;
+    shrink.phases = false;
+    shrink.clauses = false;
+    shrink.literals = false;
+    shrink.basic = false;
+    shrink.options = false;
+    disable = false;
+    map = false;
+    reduce =  false;
+    seeds = false;
+    ignore_resource_limits = false;
+    execute = false;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+struct Shared {
+  int64_t solved;
+  int64_t incremental;
+  int64_t unsat;
+  int64_t sat;
+  int64_t memout;
+  int64_t timeout;
+};
+
+// This is the class for the Mobical application.
+
+class Mobical : public Handler {
+
+  /*----------------------------------------------------------------------*/
+
+  friend struct FailedCall;
+  friend class Reader;
+  friend class Trace;
+  friend struct ValCall;
+  friend struct MeltCall;
+
+  /*----------------------------------------------------------------------*/
+
+  // We have the following modes, where 'RANDOM' mode can not be combined
+  // with any other mode and 'OUTPUT' mode requires that 'SEED' or 'INPUT'
+  // mode is set too, but it is not possible to combine 'SEED' and 'INPUT'.
+
+  enum { RANDOM = 1, SEED = 2, INPUT = 4, OUTPUT = 8 };
+
+  int mode;             // No 'Mode mode' due to 'mode |= ...' below.
+
+  void check_mode_valid ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Global options (set by parsing command line options in 'main').
+
+  DoNot donot;
+  Force force;
+  bool verbose;
+#ifdef LOGGING
+  bool add_set_log_to_true;
+#endif
+  bool add_dump_before_solve;
+  bool add_stats_after_solve;
+
+  /*----------------------------------------------------------------------*/
+
+  bool shrinking;       // In the middle of shrinking.
+  bool running;         // In the middle of running.
+
+  int64_t time_limit;   // in seconds, none if zero
+  int64_t space_limit;  // in MB, none if zero
+
+  Terminal & terminal;
+
+  void header ();               // Print right part of header.
+
+  /*----------------------------------------------------------------------*/
+
+  bool is_unsigned_str (const char *);
+  uint64_t parse_seed (const char *);
+
+  /*----------------------------------------------------------------------*/
+
+  const char * prefix_string () {
+    if (!terminal.colors ()) return "m ";
+    else return "\033[34mm \033[0m";
+  }
+
+  void prefix () { cerr << prefix_string () << flush; }
+
+  void error_prefix () {
+    fflush (stderr);
+    fflush (stdout);
+    terminal.bold ();
+    fputs ("mobical: ", stderr);
+    terminal.normal ();
+  }
+
+  void hline ();                // print horizontal line
+  void empty_line ();           // print empty line
+
+  /*----------------------------------------------------------------------*/
+
+  void summarize (Trace & trace, bool bright = false);
+  void progress (Trace & trace) { notify (trace, -1); }
+
+  string notified;
+
+#ifndef QUIET
+  int progress_counter;
+  double last_progress_time;
+#endif
+
+  void notify (Trace & trace, signed char ch = 0);
+
+  /*----------------------------------------------------------------------*/
+
+  Shared * shared;              // shared among parent and child processes
+
+  int64_t traces;
+  int64_t spurious;
+
+  void print_statistics ();
+
+  /*----------------------------------------------------------------------*/
+
+  void die (const char * fmt, ...);
+  void warning (const char * fmt, ...);
+
+public:
+
+  Mobical ();
+  ~Mobical ();
+
+  void catch_signal (int);      // Implement 'Handler'.
+
+  int main (int, char**);
+};
+
+/*------------------------------------------------------------------------*/
+
+CaDiCaL::Mobical mobical;
+
+/*------------------------------------------------------------------------*/
+
+// The mode invariant of the last comment can be checked with this code:
+
+void Mobical::check_mode_valid () {
+#ifndef NDEBUG
+  assert (mode & (RANDOM | SEED | INPUT | OUTPUT));
+  if (mode & RANDOM) assert (!(mode & SEED));
+  if (mode & RANDOM) assert (!(mode & INPUT));
+  if (mode & RANDOM) assert (!(mode & OUTPUT));
+  if (mode & OUTPUT) assert (mode & (SEED | INPUT));
+  assert (!((mode & SEED) && (mode & INPUT)));
+#endif
+}
+
+/* As a formula this is
+
+  (RANDOM | SEED | INPUT | OUTPUT) &
+  (RANDOM -> !SEED)
+  (RANDOM -> !INPUT) &
+  (RANDOM -> !OUTPUT) &
+  (OUTPUT -> SEED | INPUT) &
+  !(SEED & INPUT)
+
+It has exactly the following 5 out of 16 models
+
+  RANDOM !SEED !INPUT !OUTPUT
+  !RANDOM SEED !INPUT !OUTPUT
+  !RANDOM SEED !INPUT OUTPUT
+  !RANDOM !SEED INPUT OUTPUT
+  !RANDOM !SEED INPUT !OUTPUT
+*/
+
+/*------------------------------------------------------------------------*/
+
+void Mobical::die (const char * fmt, ...) {
+  error_prefix ();
+  terminal.red (true);
+  fputs ("error: ", stderr);
+  terminal.normal ();
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  terminal.reset ();
+  exit (1);
+}
+
+void Mobical::warning (const char * fmt, ...) {
+  error_prefix ();
+  terminal.yellow ();
+  fputs ("warning: ", stderr);
+  terminal.normal ();
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Abstraction of individual API calls.  The call sequences are assumed to
+// have the following structure
+//
+//   INIT
+//   (SET|ALWAYS)*
+//   (   (ADD|ASSUME|ALWAYS)*
+//       [ (SOLVE|SIMPLIFY|LOOKAHEAD) (VAL|FAILED|ALWAYS)* ]
+//   )*
+//   [ RESET ]
+//
+// where 'ALWAYS' calls as defined below do not change the state.  With
+// the other short-cuts below we can abstract this to
+//
+//   CONFIG* (BEFORE* [ PROCESS AFTER* ] )* [ RESET ]
+//
+// If traces are read then they are checked to have this structure.  We
+// check that 'ADD' sequences terminate by adding zero literal before
+// another call is made ('ASSUME|ALWAYS|SOLVE|SIMPLIFY|LOOKAHEAD').
+//
+// Furthermore the execution engine (both for read and generated traces)
+// makes sure that additional contract requirements are always met.  For
+// instance 'val' is only executed if the solver is in the 'SATISFIABLE'
+// state, and similar for 'failed', 'melt' etc.
+//
+// If the user wants to understand why a trace obtained through
+// 'CADICAL_API_TRACE' is violating an API contract, then these checks
+// are problematic and can be disabled by using the command line option
+// '--do-not-enforce-contracts'.
+//
+// Note that our model based tester is actually more restrictive and does
+// produce all these possible call sequences.  For instance it first adds
+// all clauses before making assumptions and also does not mix in these
+// 'ALWAYS' calls in all possible ways.
+
+struct Call {
+
+  enum Type {
+
+    INIT        = (1<<0),
+    SET         = (1<<1),
+    CONFIGURE   = (1<<2),
+
+    VARS        = (1<<3),
+    ACTIVE      = (1<<4),
+    REDUNDANT   = (1<<5),
+    IRREDUNDANT = (1<<6),
+    RESERVE     = (1<<7),
+
+    ADD         = (1<<8),
+    ASSUME      = (1<<9),
+
+    SOLVE       = (1<<10),
+    SIMPLIFY    = (1<<11),
+    LOOKAHEAD   = (1<<12),
+    CUBING      = (1<<13),
+
+    VAL         = (1<<14),
+    FAILED      = (1<<15),
+    FIXED       = (1<<16),
+
+    FREEZE      = (1<<17),
+    FROZEN      = (1<<18),
+    MELT        = (1<<19),
+
+    LIMIT       = (1<<20),
+    OPTIMIZE    = (1<<21),
+
+    DUMP        = (1<<22),
+    STATS       = (1<<23),
+
+    RESET       = (1<<24),
+
+    ALWAYS = VARS | ACTIVE | REDUNDANT | IRREDUNDANT | FREEZE | FROZEN | MELT |
+             LIMIT | OPTIMIZE | DUMP | STATS | RESERVE | FIXED,
+
+    CONFIG = INIT | SET | CONFIGURE | ALWAYS,
+    BEFORE = ADD | ASSUME | ALWAYS,
+    PROCESS = SOLVE | SIMPLIFY | LOOKAHEAD | CUBING,
+    AFTER = VAL | FAILED | ALWAYS,
+  };
+
+  Type type;            // Explicit typing.
+
+  int arg;              // Argument if necessary.
+  int64_t res;          // Compute result if any.
+  char * name;          // Option name for 'set' and 'config'
+  int val;              // Option value for 'set'.
+
+  Call (Type t, int a = 0, int r = 0, const char * o = 0, int v = 0) :
+    type (t), arg (a), res (r), name (o ? strdup (o) : 0), val (v) { }
+
+  virtual ~Call () { if (name) free (name); }
+
+  virtual void execute (Solver * &) = 0;
+  virtual void print (ostream & o) = 0;
+  virtual const char * keyword ()  = 0;
+  virtual Call * copy () = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+static bool config_type (Call::Type t) {
+  return (((int) t & (int) Call::CONFIG)) != 0;
+}
+
+static bool before_type (Call::Type t) {
+  return (((int) t & (int) Call::BEFORE)) != 0;
+}
+
+static bool process_type (Call::Type t) {
+  return (((int) t & (int) Call::PROCESS)) != 0;
+}
+
+static bool after_type (Call::Type t) {
+  return (((int) t & (int) Call::AFTER)) != 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The model of valid API sequences is rather implicit.  First it is encoded
+// in the random generator, by for instance adding options with 'set' only
+// right after initialization through 'init', which is also enforced during
+// parsing traces, but also in guards for executing certain API calls,
+// marked 'CONTRACT' below.  For instance 'val' is only allowed if the
+// solver is in the 'SATISFIED' state.
+
+struct InitCall : public Call {
+  InitCall () : Call (INIT) { }
+  void execute (Solver * & s) { s = new Solver (); }
+  void print (ostream & o) { o << "init" << endl; }
+  Call * copy () { return new InitCall (); }
+  const char * keyword () { return "init"; }
+};
+
+struct VarsCall : public Call {
+  VarsCall () : Call (VARS) { }
+  void execute (Solver * & s) { res = s->vars (); }
+  void print (ostream & o) { o << "vars" << endl; }
+  Call * copy () { return new VarsCall (); }
+  const char * keyword () { return "vars"; }
+};
+
+struct ActiveCall : public Call {
+  ActiveCall () : Call (ACTIVE) { }
+  void execute (Solver * & s) { res = s->active (); }
+  void print (ostream & o) { o << "active" << endl; }
+  Call * copy () { return new ActiveCall (); }
+  const char * keyword () { return "active"; }
+};
+
+struct RedundantCall : public Call {
+  RedundantCall () : Call (REDUNDANT) { }
+  void execute (Solver * & s) { res = s->redundant (); }
+  void print (ostream & o) { o << "redundant" << endl; }
+  Call * copy () { return new RedundantCall (); }
+  const char * keyword () { return "redundant"; }
+};
+
+struct IrredundantCall : public Call {
+  IrredundantCall () : Call (IRREDUNDANT) { }
+  void execute (Solver * & s) { res = s->irredundant (); }
+  void print (ostream & o) { o << "irredundant" << endl; }
+  Call * copy () { return new IrredundantCall (); }
+  const char * keyword () { return "irredundant"; }
+};
+
+struct ReserveCall : public Call {
+  ReserveCall (int max_var) : Call (RESERVE, max_var) { }
+  void execute (Solver * & s) { s->reserve (arg); }
+  void print (ostream & o) { o << "reserve " << arg << endl; }
+  Call * copy () { return new ReserveCall (arg); }
+  const char * keyword () { return "reserve"; }
+};
+
+struct SetCall : public Call {
+  SetCall (const char * o, int v) : Call (SET, 0, 0, o, v) { }
+  void execute (Solver * & s) { s->set (name, val); }
+  void print (ostream & o) { o << "set " << name << ' ' << val << endl; }
+  Call * copy () { return new SetCall (name, val); }
+  const char * keyword () { return "set"; }
+};
+
+struct ConfigureCall : public Call {
+  ConfigureCall (const char * o) : Call (CONFIGURE, 0, 0, o) { }
+  void execute (Solver * & s) { s->configure (name); }
+  void print (ostream & o) { o << "configure " << name << endl; }
+  Call * copy () { return new ConfigureCall (name); }
+  const char * keyword () { return "configure"; }
+};
+
+struct LimitCall : public Call {
+  LimitCall (const char * o, int v) : Call (LIMIT, 0, 0, o, v) { }
+  void execute (Solver * & s) { s->limit (name, val); }
+  void print (ostream & o) { o << "limit " << name << ' ' << val << endl; }
+  Call * copy () { return new LimitCall (name, val); }
+  const char * keyword () { return "limit"; }
+};
+
+struct OptimizeCall : public Call {
+  OptimizeCall (int v) : Call (OPTIMIZE, 0, 0, 0, v) { }
+  void execute (Solver * & s) { s->optimize (val); }
+  void print (ostream & o) { o << "optimize " << val << endl; }
+  Call * copy () { return new OptimizeCall (val); }
+  const char * keyword () { return "optimize"; }
+};
+
+struct ResetCall : public Call {
+  ResetCall () : Call (RESET) { }
+  void execute (Solver * & s) { delete s; s = 0; }
+  void print (ostream & o) { o << "reset" << endl; }
+  Call * copy () { return new ResetCall (); }
+  const char * keyword () { return "reset"; }
+};
+
+struct AddCall : public Call {
+  AddCall (int l) : Call (ADD, l) { }
+  void execute (Solver * & s) { s->add (arg); }
+  void print (ostream & o) { o << "add " << arg << endl; }
+  Call * copy () { return new AddCall (arg); }
+  const char * keyword () { return "add"; }
+};
+
+struct AssumeCall : public Call {
+  AssumeCall (int l) : Call (ASSUME, l) { }
+  void execute (Solver * & s) { s->assume (arg); }
+  void print (ostream & o) { o << "assume " << arg << endl; }
+  Call * copy () { return new AssumeCall (arg); }
+  const char * keyword () { return "assume"; }
+};
+
+struct SolveCall : public Call {
+  SolveCall (int r = 0) : Call (SOLVE, 0, r) { }
+  void execute (Solver * & s) { res = s->solve (); }
+  void print (ostream & o) { o << "solve " << res << endl; }
+  Call * copy () { return new SolveCall (res); }
+  const char * keyword () { return "solve"; }
+};
+
+struct SimplifyCall : public Call {
+  SimplifyCall (int rounds, int r = 0) : Call (SIMPLIFY, rounds, r) { }
+  void execute (Solver * & s) { res = s->simplify (arg); }
+  void print (ostream & o) { o << "simplify " << arg << " " << res << endl; }
+  Call * copy () { return new SimplifyCall (arg, res); }
+  const char * keyword () { return "simplify"; }
+};
+
+struct LookaheadCall : public Call {
+  LookaheadCall (int r = 0) : Call (LOOKAHEAD, 0, r) { }
+  void execute (Solver * & s) { res = s->lookahead (); }
+  void print (ostream & o) { o << "lookahead " << res << endl; }
+  Call * copy () { return new LookaheadCall (res); }
+  const char * keyword () { return "lookahead"; }
+};
+
+struct CubingCall : public Call {
+  CubingCall(int r = 1) : Call(CUBING, 0, r) {}
+  void execute(Solver *&s) { (void)s->generate_cubes(arg); }
+  void print(ostream &o) { o << "cubing " << res << endl; }
+  Call *copy() { return new CubingCall(res); }
+  const char *keyword() { return "cubing"; }
+};
+
+struct ValCall : public Call {
+  ValCall (int l, int r = 0) : Call (VAL, l, r) { }
+  void execute (Solver * & s) {
+    if (mobical.donot.enforce) res = s->val (arg);
+    else if (s->state () == SATISFIED) res = s->val (arg);
+    else res = 0;
+  }
+  void print (ostream & o) { o << "val " << arg << ' ' << res << endl; }
+  Call * copy () { return new ValCall (arg, res); }
+  const char * keyword () { return "val"; }
+};
+
+struct FixedCall : public Call {
+  FixedCall (int l, int r = 0) : Call (FIXED, l, r) { }
+  void execute (Solver * & s) { res = s->fixed (arg); }
+  void print (ostream & o) { o << "fixed " << arg << ' ' << res << endl; }
+  Call * copy () { return new FixedCall (arg, res); }
+  const char * keyword () { return "fixed"; }
+};
+
+struct FailedCall : public Call {
+  FailedCall (int l, int r = 0) : Call (FAILED, l, r) { }
+  void execute (Solver * & s) {
+    if (mobical.donot.enforce) res = s->failed (arg);
+    else if (s->state () == UNSATISFIED) res = s->failed (arg);
+    else res = 0;
+  }
+  void print (ostream & o) { o << "failed " << arg << ' ' << res << endl; }
+  Call * copy () { return new FailedCall (arg, res); }
+  const char * keyword () { return "failed"; }
+};
+
+struct FreezeCall : public Call {
+  FreezeCall (int l) : Call (FREEZE, l) { }
+  void execute (Solver * & s) { s->freeze (arg); }
+  void print (ostream & o) { o << "freeze " << arg << endl; }
+  Call * copy () { return new FreezeCall (arg); }
+  const char * keyword () { return "freeze"; }
+};
+
+struct MeltCall : public Call {
+  MeltCall (int l) : Call (MELT, l) { }
+  void execute (Solver * & s) {
+    if (mobical.donot.enforce || s->frozen (arg))
+      s->melt (arg);
+  }
+  void print (ostream & o) { o << "melt " << arg << endl; }
+  Call * copy () { return new MeltCall (arg); }
+  const char * keyword () { return "melt"; }
+};
+
+struct FrozenCall : public Call {
+  FrozenCall (int l, int r = 0) : Call (FROZEN, l, r) { }
+  void execute (Solver * & s) { res = s->frozen (arg); }
+  void print (ostream & o) { o << "frozen " << arg << ' ' << res << endl; }
+  Call * copy () { return new FrozenCall (arg, res); }
+  const char * keyword () { return "frozen"; }
+};
+
+struct DumpCall : public Call {
+  DumpCall () : Call (DUMP) { }
+  void execute (Solver * & s) { s->dump_cnf (); }
+  void print (ostream & o) { o << "dump" << endl; }
+  Call * copy () { return new DumpCall (); }
+  const char * keyword () { return "dump"; }
+};
+
+struct StatsCall : public Call {
+  StatsCall () : Call (STATS) { }
+  void execute (Solver * & s) { s->statistics (); }
+  void print (ostream & o) { o << "stats" << endl; }
+  Call * copy () { return new StatsCall (); }
+  const char * keyword () { return "stats"; }
+};
+
+/*------------------------------------------------------------------------*/
+
+class Trace {
+
+  int64_t id;
+  uint64_t seed;
+
+  Solver * solver;
+  vector<Call*> calls;
+
+  friend class Reader;
+
+public:
+
+  static int64_t generated;
+  static int64_t executed;
+  static int64_t failed;
+  static int64_t ok;
+
+#define SIGNALS \
+  SIGNAL(SIGINT) \
+  SIGNAL(SIGSEGV) \
+  SIGNAL(SIGABRT) \
+  SIGNAL(SIGTERM) \
+  SIGNAL(SIGBUS) \
+
+#define SIGNAL(SIG) \
+  static void (*old_ ## SIG ## _handler) (int);
+  SIGNALS
+#undef SIGNAL
+  static void child_signal_handler (int);
+  static void init_child_signal_handlers ();
+  static void reset_child_signal_handlers ();
+
+  Trace (int64_t i = 0, uint64_t s = 0) : id (i), seed (s), solver (0) { }
+
+  void clear () {
+    while (!calls.empty ()) {
+      Call * c = calls.back ();
+      delete c;
+      calls.pop_back ();
+    }
+    if (solver) delete solver;
+    solver = 0;
+  }
+
+  ~Trace () { clear (); }
+
+  void push_back (Call * c) { calls.push_back (c); }
+
+  void print (ostream & o) {
+    for (size_t i = 0; i < calls.size (); i++)
+      calls[i]->print (o << i << ' ');
+  }
+
+  void execute () {
+    executed++;
+    bool first = true;
+    for (size_t i = 0; i < calls.size (); i++) {
+      Call * c = calls[i];
+      if (mobical.shared && process_type (c->type)) {
+        mobical.shared->solved++;
+        if (first) first = false;
+        else mobical.shared->incremental++;
+        c->execute (solver);
+        if (c->res == 10) mobical.shared->sat++;
+        if (c->res == 20) mobical.shared->unsat++;
+      } else c->execute (solver);
+    }
+  }
+
+  int vars () {
+    int res = 0;
+    for (size_t i = 0; i < calls.size (); i++) {
+      Call * c = calls[i];
+      int tmp = abs (c->arg);
+      if (tmp > res) res = tmp;
+    }
+    return res;
+  }
+
+  int64_t clauses () {
+    int64_t res = 0;
+    for (size_t i = 0; i < calls.size (); i++) {
+      Call * c = calls[i];
+      if (c->type == Call::ADD && !c->arg) res++;
+    }
+    return res;
+  }
+
+  int64_t literals () {
+    int64_t res = 0;
+    for (size_t i = 0; i < calls.size (); i++) {
+      Call * c = calls[i];
+      if (c->type == Call::ADD && c->arg) res++;
+    }
+    return res;
+  }
+
+  int64_t phases () {
+    int64_t res = 0;
+    bool last = true;
+    for (size_t i = 0; i < calls.size (); i++) {
+      Call * c = calls[i];
+      if (last &&
+          c->type != Call::VAL &&
+          c->type != Call::FAILED &&
+          c->type != Call::FROZEN &&
+          c->type != Call::RESET) res++, last = false;
+      if (process_type (c->type)) last = true;
+    }
+    return res;
+  }
+
+  size_t size () { return calls.size (); }
+  Call * operator[] (size_t i) { return calls[i]; }
+
+  void generate (uint64_t id, uint64_t seed);
+
+  int fork_and_execute ();
+  void shrink (int expected);
+
+  void write_prefixed_seed (const char * prefix);
+  void write_path (const char * path);
+
+  static bool ignored_option (const char * name);
+  bool ignore_option (const char *, int max_var);
+  int64_t option_high_value (const char *,
+                             int64_t def, int64_t lo, int64_t hi);
+
+private:
+
+  void notify (char ch = 0) { mobical.notify (*this, ch); }
+  void progress () { mobical.progress (*this); }
+
+  struct Segment {
+    size_t lo, hi;
+    Segment (size_t l, size_t h) : lo (l), hi (h)
+      { assert (0 < l), assert (l < h); }
+  };
+
+  typedef vector<Segment> Segments;
+  bool shrink_segments (Segments &, int expected);
+
+  void add_options (int expected);
+  bool shrink_phases (int expected);
+  bool shrink_clauses (int expected);
+  bool shrink_literals (int expected);
+  bool shrink_basic (int expected);
+  bool shrink_disable (int expected);
+  bool reduce_values (int expected);
+  void map_variables (int expected);
+  void shrink_options (int expected);
+
+  size_t first_option ();
+  size_t last_option ();
+
+  Call * find_option_by_prefix (const char * name);
+  Call * find_option_by_name (const char * name);
+
+  void generate_options (Random &, Size);
+  void generate_queries (Random &);
+  void generate_reserve (Random &, int vars);
+  void generate_clause (Random &, int minvars, int maxvars, int uniform);
+  void generate_assume (Random &, int vars);
+  void generate_process (Random &);
+  void generate_values (Random &, int vars);
+  void generate_frozen (Random &, int vars);
+  void generate_failed (Random &, int vars);
+  void generate_freeze (Random &, int vars);
+  void generate_melt (Random &);
+
+  void generate_limits (Random &);
+};
+
+/*------------------------------------------------------------------------*/
+
+class Reader {
+
+  Mobical & mobical;
+  Trace & trace;
+
+  const char * path;
+  FILE * file;
+  int lineno;
+  bool close;
+
+  int next () { return getc (file); }
+
+  void error (const char * fmt, ...);
+
+public:
+
+  Reader (Mobical & m, Trace & t, const char * p)
+  :
+    mobical (m), trace (t), lineno (1)
+  {
+    assert (p);
+    if (!strcmp (p, "-")) path = "<stdin>", file = stdin, close = false;
+    else if (!(file = fopen (p, "r")))
+      mobical.die ("can not read '%s'", p);
+    else path = p, close = true;
+  }
+
+  ~Reader () { if (close) fclose (file); }
+
+  void parse ();
+};
+
+/*------------------------------------------------------------------------*/
+
+size_t Trace::first_option () {
+  size_t res;
+  for (res = 0; res < size (); res++)
+    if (calls[res]->type == Call::SET) return res;
+  return res;
+}
+
+size_t Trace::last_option () {
+  size_t res;
+  for (res = 0; res < size (); res++) {
+    Call * c = calls[res];
+    if (c->type == Call::INIT) continue;
+    if (c->type == Call::SET) continue;
+    break;
+  }
+  return res;
+}
+
+Call * Trace::find_option_by_prefix (const char * name) {
+  size_t last = last_option ();
+  Call * res = 0;
+  for (size_t i = first_option (); i < last; i++) {
+    Call * c = calls[i];
+    if (res && strlen (res->name) < strlen (c->name)) continue;
+    if (has_prefix (name, c->name)) res = c;
+  }
+  return res;
+}
+
+Call * Trace::find_option_by_name (const char * name) {
+  size_t last = last_option ();
+  Call * res = 0;
+  for (size_t i = first_option (); i < last; i++) {
+    Call * c = calls[i];
+    if (!strcmp (c->name, name)) res = c;
+  }
+  return res;
+}
+
+// Some options are never part of generated traces.
+//
+bool Trace::ignored_option (const char * name) {
+
+  if (!strcmp (name, "checkfrozen")) return true;
+  if (!strcmp (name, "terminateint")) return true;
+
+  return false;
+}
+
+// Check whether the trace already contains an option which disables the
+// option 'name'.  Here we assume that an option disables another one if the
+// disabling one has as name proper prefix of the disabled one and the value
+// of the former is set to zero in the trace.
+//
+bool Trace::ignore_option (const char * name, int max_var) {
+
+  if (ignored_option (name)) return true;
+
+  // There are options which should be kept at their default value unless
+  // the formula is really small.  Otherwise the solver might run 'forever'.
+  //
+  if (max_var > SMALL) {
+    if (!strcmp (name, "reduce")) return true;
+  }
+
+  const Call * c = find_option_by_prefix (name);
+  assert (!c || has_prefix (name, c->name));
+  if (c && strlen (c->name) < strlen (name) && !c->val) return true;
+
+  return false;
+}
+
+// For incomplete solving phases such as 'walk' we do not want to increase
+// the option value above the default and similarly for elimination bounds.
+//
+int64_t Trace::option_high_value (const char * name,
+                                  int64_t def, int64_t lo, int64_t hi) {
+  assert (lo <= def), assert (def <= hi);
+  if (!strcmp (name, "walkmaxeff")) return def;
+  if (!strcmp (name, "walkmineff")) return def;
+  if (!strcmp (name, "elimboundmax")) return 256;
+  if (!strcmp (name, "elimboundmin")) return 256;
+  (void) lo;
+  return hi;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Trace::generate_options (Random & random, Size size) {
+
+  // In 10% of the cases do not change any options.
+  //
+  if (random.generate_double () < 0.1) return;
+
+  // In order to increase throughput we enable 'walk' in 5% tests, which
+  // means disabling it in 95% of the tests.
+  //
+  if (random.generate_double () < 0.95)
+    push_back (new SetCall ("walk", 0));
+
+  // Also for checking models and assumptions, but with 80% probability.
+  //
+  if (random.generate_double () < 0.8)
+    push_back (new SetCall ("check", 1));
+
+  // In 10% of the remaining cases we use a configuration.
+  //
+  if (random.generate_double () < 0.1) {
+    const auto configs = Config::begin ();
+    const int size = Config::end () - configs;
+    const int pos = random.pick_int (0, size-1);
+    const char * config = configs[pos];
+    assert (Config::has (config));
+    push_back (new ConfigureCall (config));
+  }
+
+  // This is the fraction of options changed.
+  //
+  double fraction = random.generate_double ();
+
+  // Generate a list of options, different from default values.
+  //
+  for (auto it = Options::begin (); it != Options::end (); it++)
+  {
+    const Option & o = *it;
+
+    // This should not be reachable unless the low and high value of an
+    // option in 'options.hpp' are the same.
+    //
+    if (o.lo == o.hi) continue;
+
+    // We keep choosing the value for 'simplify' and 'walk' out of the loop
+    // (see the arguments described above).
+    //
+    if (!strcmp (o.name, "simplify")) continue;
+    if (!strcmp (o.name, "walk")) continue;
+
+    // Probability to change an option is 'fraction'.
+    //
+    if (random.generate_double () < fraction) continue;
+
+    // Unless we have to ignore it.
+    //
+    if (ignore_option (o.name, size)) continue;
+
+    int val;
+    int64_t hi = option_high_value (o.name, o.def, o.lo, o.hi);
+    if (o.lo < hi) {
+      bool uniform = random.generate_double () < 0.05;
+      if (uniform) {
+        do val = random.pick_int (o.lo, hi);
+        while (val == o.def);
+      } else {                            // log uniform
+        int64_t range = hi - (int64_t) o.lo;
+        int log;
+        assert (range <= INT_MAX);
+        for (log = 0; log < 30 && (1<<log) < range; log++)
+          if (random.generate_bool ()) break;
+        if ((1<<log) < range) range = (1l<<log);
+        val = o.lo + random.pick_int (0, range);
+      }
+    } else val = o.lo;
+    push_back (new SetCall (o.name, val));
+  }
+
+#ifdef LOGGING
+  if (mobical.add_set_log_to_true)
+    push_back (new SetCall ("log", 1));
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+void Trace::generate_queries (Random & random) {
+  if (random.generate_double () < 0.02) push_back (new VarsCall ());
+  if (random.generate_double () < 0.02) push_back (new ActiveCall ());
+  if (random.generate_double () < 0.02) push_back (new RedundantCall ());
+  if (random.generate_double () < 0.02) push_back (new IrredundantCall ());
+}
+
+/*------------------------------------------------------------------------*/
+
+void Trace::generate_reserve (Random & random, int max_var) {
+  if (random.generate_double () > 0.01) return;
+  int new_max_var = random.pick_int (0, 1.1*max_var);
+  push_back (new ReserveCall (new_max_var));
+}
+
+/*------------------------------------------------------------------------*/
+
+void Trace::generate_limits (Random & random) {
+  if (random.generate_double () < 0.05)
+    push_back (new LimitCall ("terminate", random.pick_log (0, 1e5)));
+  if (random.generate_double () < 0.05)
+    push_back (new LimitCall ("conflicts", random.pick_log (0, 1e4)));
+  if (random.generate_double () < 0.05)
+    push_back (new LimitCall ("decisions", random.pick_log (0, 1e4)));
+  if (random.generate_double () < 0.1)
+    push_back (new LimitCall ("preprocessing", random.pick_int (0, 10)));
+  if (random.generate_double () < 0.05)
+    push_back (new LimitCall ("localsearch", random.pick_int (0, 1)));
+  if (random.generate_double () < 0.02)
+    push_back (new OptimizeCall (random.pick_int (0, 31)));
+}
+
+/*------------------------------------------------------------------------*/
+
+static int pick_size (Random & random, int vars) {
+  int res;
+  double prop = random.generate_double ();
+       if (prop < 0.0001) res = 0;
+  else if (prop < 0.001) res = 1;
+  else if (prop < 0.01) res = 2;
+  else if (prop < 0.90) res = 3;
+  else if (prop < 0.95) res = 4;
+  else res = random.pick_int (5, 20);
+  if (res > vars) res = vars;
+  return res;
+}
+
+static int pick_literal (Random & random,
+                         int minvars, int maxvars,
+                         vector<int> & clause) {
+  assert (minvars <= maxvars);
+  int res = 0;
+  while (!res) {
+    int idx = random.pick_int (minvars, maxvars);
+    double prop = random.generate_double ();
+    if (prop > 0.001) {
+      bool duplicated = false;
+      for (size_t i = 0; !duplicated && i < clause.size (); i++)
+        duplicated = (abs (clause[i]) == idx);
+      if (duplicated) continue;
+    }
+    bool sign = random.generate_bool ();
+    res = sign ? -idx : idx;
+  }
+  return res;
+}
+
+void Trace::generate_clause (Random & random,
+                             int minvars, int maxvars,
+                             int uniform) {
+  assert (minvars <= maxvars);
+  int maxsize = maxvars - minvars + 1;
+  int size = uniform ? uniform : pick_size (random, maxsize);
+  vector<int> clause;
+  for (int i = 0; i < size; i++) {
+    int lit = pick_literal (random, minvars, maxvars, clause);
+    push_back (new AddCall (lit));
+    clause.push_back (lit);
+  }
+  push_back (new AddCall (0));
+}
+
+/*------------------------------------------------------------------------*/
+
+void Trace::generate_assume (Random & random, int vars) {
+  if (random.generate_double () < 0.15) return;
+  int count;
+  if (random.generate_bool ()) count = 1;
+  else count = random.pick_int (1, vars + 1);
+  const int max_vars = vars + 2;
+  bool * picked = new bool [max_vars + 1];
+  for (int i = 1; i <= max_vars; i++) picked[i] = false;
+  for (int i = 0; i < count; i++) {
+    int idx;
+    do idx = random.pick_int (1, max_vars); while (picked[idx]);
+    picked[idx] = 1;
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new AssumeCall (lit));
+  }
+  delete [] picked;
+  if (random.generate_double () < 0.1) {
+    int idx = random.pick_int (1, max_vars);
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new AssumeCall (lit));
+  }
+}
+
+void Trace::generate_values (Random & random, int vars) {
+  if (random.generate_double () < 0.1) return;
+  double fraction = random.generate_double ();
+  for (int idx = 1; idx <= vars; idx++) {
+    if (fraction < random.generate_double ()) continue;
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new ValCall (lit));
+  }
+  if (random.generate_double () < 0.1) {
+    int idx = random.pick_int (vars + 1, vars*1.5 + 1);
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new ValCall (lit));
+  }
+}
+
+void Trace::generate_failed (Random & random, int vars) {
+  if (random.generate_double () < 0.05) return;
+  double fraction = random.generate_double ();
+  for (int idx = 1; idx <= vars; idx++) {
+    if (fraction < random.generate_double ()) continue;
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new FailedCall (lit));
+  }
+  if (random.generate_double () < 0.05) {
+    int idx = random.pick_int (vars + 1, vars*1.5 + 1);
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new FailedCall (lit));
+  }
+}
+
+void Trace::generate_frozen (Random & random, int vars) {
+  if (random.generate_double () < 0.05) return;
+  double fraction = random.generate_double ();
+  for (int idx = 1; idx <= vars; idx++) {
+    if (fraction < random.generate_double ()) continue;
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new FrozenCall (lit));
+  }
+  if (random.generate_double () < 0.05) {
+    int idx = random.pick_int (vars + 1, vars*1.5 + 1);
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new FrozenCall (lit));
+  }
+}
+
+void Trace::generate_melt (Random & random) {
+  if (random.generate_bool ()) return;
+  int m = vars ();
+  int64_t * frozen = new int64_t [m + 1];
+  for (int i = 1; i <= m; i++) frozen[i] = 0;
+  for (size_t i = 0; i < size (); i++) {
+    Call * c = calls[i];
+    if (c->type == Call::MELT) {
+      int idx = abs (c->arg);
+      assert (idx), assert (idx <= m);
+      assert (frozen[idx] > 0);
+      frozen[idx]--;
+    } else if (c->type == Call::FREEZE) {
+      int idx = abs (c->arg);
+      assert (idx), assert (idx <= m);
+      frozen[idx]++;
+    }
+  }
+  vector<int> candidates;
+  for (int i = 1; i <= m; i++)
+    if (frozen[i])
+      candidates.push_back (i);
+  delete [] frozen;
+  double fraction = random.generate_double () * 0.4;
+  for (auto idx : candidates) {
+    if (random.generate_double () <= fraction) continue;
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new MeltCall (lit));
+  }
+}
+
+void Trace::generate_freeze (Random & random, int vars) {
+  if (random.generate_bool ()) return;
+  double fraction = random.generate_double () * 0.5;
+  for (int idx = 1; idx <= vars; idx++) {
+    if (random.generate_double () <= fraction) continue;
+    int lit = random.generate_bool () ? -idx : idx;
+    push_back (new FreezeCall (lit));
+  }
+}
+
+void Trace::generate_process (Random & random) {
+  if (mobical.add_dump_before_solve)
+    push_back (new DumpCall ());
+
+  const double fraction = random.generate_double ();
+
+  if (fraction < 0.6) push_back(new SolveCall());
+  else if (fraction > 0.99) {
+    const int depth = random.pick_int (0, 10);
+    push_back(new CubingCall(depth));
+  }
+  else if (fraction > 0.9) push_back (new LookaheadCall ());
+  else {
+    const int rounds = random.pick_int (0, 10);
+    push_back (new SimplifyCall (rounds));
+  }
+
+  if (mobical.add_stats_after_solve)
+    push_back (new StatsCall ());
+}
+
+void Trace::generate (uint64_t i, uint64_t s) {
+
+  id = i;
+  seed = s;
+
+  push_back (new InitCall ());
+
+  Random random (seed);
+
+  Size size;
+
+  if (mobical.force.size) size = mobical.force.size;
+  else {
+    switch (random.pick_int (1, 3)) {
+      case 1 : size = SMALL; break;
+      case 2 : size = MEDIUM; break;
+      default : size = BIG; break;
+    }
+  }
+
+  generate_options (random, size);
+
+  int calls;
+  if (mobical.force.phases < 0) calls = random.pick_int (1, 4);
+  else                          calls = mobical.force.phases;
+
+  int minvars, maxvars = 0;
+
+  for (int call = 0; call < calls; call++) {
+
+    int range;
+    double ratio;
+    int uniform;
+
+         if (size == SMALL)  range = random.pick_int (1, SMALL);
+    else if (size == MEDIUM) range = random.pick_int (SMALL+1, MEDIUM);
+    else                     range = random.pick_int (MEDIUM+1, BIG);
+
+    if (random.generate_bool ()) uniform = 0;
+    else if (size == SMALL)      uniform = random.pick_int (3, 7);
+    else if (size == MEDIUM)     uniform = random.pick_int (3, 4);
+    else                         uniform = random.pick_int (3, 3);
+
+    switch (uniform) {
+      default: ratio = 4.267; break;
+      case 4:  ratio = 9.931; break;
+      case 5:  ratio = 21.117; break;
+      case 6:  ratio = 43.37; break;
+      case 7:  ratio = 87.79; break;
+    }
+
+    int clauses = range * ratio;
+
+    minvars = random.pick_int (1, maxvars + 1);
+    maxvars = minvars + range;
+
+    for (int j = 0; j < clauses; j++)
+      generate_queries (random),
+      generate_reserve (random, maxvars),
+      generate_clause (random, minvars, maxvars, uniform);
+
+    generate_assume (random, maxvars);
+    generate_melt (random);
+    generate_freeze (random, maxvars);
+    generate_limits (random);
+
+    generate_process (random);
+
+    generate_values (random, maxvars);
+    generate_failed (random, maxvars);
+    generate_frozen (random, maxvars);
+  }
+
+  push_back (new ResetCall ());
+}
+
+/*------------------------------------------------------------------------*/
+
+void Mobical::hline () {
+  prefix ();
+  terminal.normal ();
+  cerr << setfill ('-') << setw (76) << "" << setfill (' ') << endl;
+  terminal.normal ();
+}
+
+void Mobical::empty_line () { cerr << prefix_string () << endl; }
+
+static int rounded_percent (double a, double b) {
+  return 0.5 + percent (a, b);
+}
+
+void Mobical::print_statistics () {
+  hline ();
+
+  prefix ();
+  cerr << "generated " << Trace::generated << " traces: ";
+  if (Trace::ok > 0) terminal.green (true);
+  cerr << Trace::ok << " ok "
+       << rounded_percent (Trace::ok, Trace::generated) << "%";
+  if (Trace::ok > 0) terminal.normal ();
+  cerr << ", ";
+  if (Trace::failed > 0) terminal.red (true);
+  cerr << Trace::failed << " failed "
+       << rounded_percent (Trace::failed, Trace::generated) << "%";
+  if (Trace::failed > 0) terminal.normal ();
+  cerr << ", " << Trace::executed << " executed"
+       << endl << flush;
+
+  if (shared) {
+    prefix ();
+    cerr << "solved " << shared->solved << ": "
+         << terr.blue_code ()
+         << shared->sat << " sat "
+         << rounded_percent (shared->sat, shared->solved) << "%"
+         << terr.normal_code ()
+         << ", "
+         << terr.magenta_code ()
+         << shared->unsat << " unsat "
+         << rounded_percent (shared->unsat, shared->solved) << "%"
+         << terr.normal_code ()
+         << ", " << shared->incremental << " incremental "
+         << rounded_percent (shared->incremental, shared->solved) << "%"
+         << endl << flush;
+    if (shared->memout || shared->timeout) {
+      prefix ();
+      cerr << "out-of-time " << shared->timeout << ", "
+           << "out-of-memory " << shared->memout
+           << endl << flush;
+    }
+  }
+
+  if (spurious) {
+    prefix ();
+    cerr << "generated " << spurious << " spurious traces "
+         << rounded_percent (spurious, traces) << "%"
+         << endl << flush;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+extern "C" {
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+}
+
+int64_t Trace::generated;
+int64_t Trace::executed;
+int64_t Trace::failed;
+int64_t Trace::ok;
+
+#define SIGNAL(SIG) \
+void (*Trace::old_ ## SIG ## _handler) (int);
+SIGNALS
+#undef SIGNAL
+
+void Trace::reset_child_signal_handlers () {
+#define SIGNAL(SIG) \
+  signal (SIG, old_ ## SIG ## _handler);
+  SIGNALS
+#undef SIGNAL
+}
+
+void Trace::child_signal_handler (int sig) {
+  struct rusage u;
+  if (!getrusage (RUSAGE_SELF, &u)) {
+    if ((int64_t) u.ru_maxrss >> 10 >= mobical.space_limit) {
+      if (mobical.shared) mobical.shared->memout++;
+      // Since there is no memout signal we just misuse SIXCPU to notify the
+      // calling process that this is a out-of-resource situation.
+      sig = SIGXCPU;
+    } else {
+      double t = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec +
+                 u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
+      if (t >= mobical.time_limit) {
+        if (mobical.shared) mobical.shared->timeout++;
+        sig = SIGXCPU;
+      }
+    }
+  }
+  reset_child_signal_handlers ();
+  raise (sig);
+}
+
+void Trace::init_child_signal_handlers () {
+#define SIGNAL(SIG) \
+  old_ ## SIG ## _handler = signal (SIG, child_signal_handler);
+  SIGNALS
+#undef SIGNAL
+}
+
+int Trace::fork_and_execute () {
+
+  cerr << flush;
+  pid_t child = mobical.donot.fork ? 0 : fork ();
+  int res = 0;
+
+  if (child) {
+
+    executed++;
+
+    int status, other = wait (&status);
+    if (other != child) res = 0;
+    else if (WIFEXITED (status)) res = WEXITSTATUS (status);
+    else if (!WIFSIGNALED (status)) res = 0;
+    else if (mobical.donot.ignore_resource_limits) res = 1;
+    else res = (WTERMSIG (status) != SIGXCPU);
+
+  } else {
+
+    if (!mobical.donot.fork && mobical.time_limit) {
+      struct rlimit rlim;
+      if (!getrlimit (RLIMIT_CPU, &rlim)) {
+        rlim.rlim_cur = mobical.time_limit;
+        setrlimit (RLIMIT_CPU, &rlim);
+      }
+    }
+
+    if (!mobical.donot.fork && mobical.space_limit) {
+      struct rlimit rlim;
+      if (!getrlimit (RLIMIT_AS, &rlim)) {
+        rlim.rlim_cur = mobical.space_limit * (1l << 20);
+        setrlimit (RLIMIT_AS, &rlim);
+      }
+    }
+
+    init_child_signal_handlers ();
+    dup2 (1, 3);
+    dup2 (2, 4);
+    int null = open ("/dev/null", O_WRONLY);
+    assert (null);
+    dup2 (null, 1);
+    dup2 (null, 2);
+    execute ();
+    close (1);
+    close (2);
+    close (null);
+    dup2 (3, 1);
+    dup2 (4, 2);
+    close (3);
+    close (4);
+    reset_child_signal_handlers ();
+
+    if (!mobical.donot.fork) exit (0);
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Delta-debugging algorithm on segments.
+
+bool Trace::shrink_segments (Trace::Segments & segments, int expected) {
+  size_t n = segments.size ();
+  if (!n) return false;
+  size_t granularity = n;
+  bool * removed = new bool[n];
+  bool * saved = new bool[n];
+  bool * ignore = new bool[size ()];
+  for (size_t i = 0; i < n; i++) removed[i] = false;
+  bool res = false;
+  Trace shrunken;
+  for (;;) {
+    for (size_t l = 0, r; l < n; l = r) {
+      r = l + granularity;
+      if (r > n) r = n;
+      size_t flipped = 0;
+      for (size_t i = 0; i < n; i++) saved[i] = false;
+      for (size_t i = l; i < r; i++)
+        if (!(saved[i] = removed[i]))
+          removed[i] = true, flipped++;
+      if (!flipped) continue;
+      for (size_t i = 0; i < size (); i++) ignore[i] = false;
+      for (size_t i = 0; i < n; i++) {
+        if (!removed[i]) continue;
+        Segment & s = segments[i];
+        for (size_t j = s.lo; j < s.hi; j++)
+          ignore[j] = true;
+      }
+      Trace tmp;
+      tmp.clear ();
+      for (size_t i = 0; i < size (); i++)
+        if (!ignore[i])
+          tmp.push_back (calls[i]->copy ());
+      progress ();
+      if (tmp.fork_and_execute () != expected) {        // failed
+        for (size_t i = l; i < r; i++)
+          removed[i] = saved[i];
+      } else {
+        shrunken.clear ();
+        for (size_t i = 0; i < tmp.size (); i++)
+          shrunken.push_back (tmp[i]->copy ());
+        res = true;                     // succeeded to shrink
+      }
+    }
+    if (granularity == 1) break;
+    granularity = (granularity + 1) / 2;
+    if (shrunken.size ()) shrunken.clear ();
+  }
+  if (res) {
+    for (size_t i = 0; i < size (); i++) ignore[i] = false;
+    for (size_t i = 0; i < n; i++) {
+      if (!removed[i]) continue;
+      Segment & s = segments[i];
+      for (size_t j = s.lo; j < s.hi; j++)
+        ignore[j] = true;
+    }
+    size_t j = 0;
+    for (size_t i = 0; i < size (); i++) {
+      Call * c = calls[i];
+      if (ignore[i]) delete c;
+      else calls[j++] = c;
+    }
+    calls.resize (j);
+    notify ();
+  }
+  delete [] ignore;
+  delete [] removed;
+  delete [] saved;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Mobical::summarize (Trace & trace, bool bright) {
+  if (bright) terminal.cyan (bright); else terminal.blue ();
+  cerr << right << setw (5) << trace.size ();
+  terminal.normal ();
+  cerr << ' ';
+  terminal.magenta (bright);
+  cerr << ' '  << right << setw (3) << trace.vars ();
+  terminal.yellow (bright);
+  cerr << ' '  <<  left << setw (4) << trace.clauses ();
+  terminal.normal ();
+  cerr << ' ';
+  if (bright) terminal.cyan (bright); else terminal.blue ();
+  cerr << setw (2) << right << trace.phases ();
+  terminal.normal ();
+}
+
+void Mobical::notify (Trace & trace, signed char ch) {
+  bool first = notified.empty ();
+#ifdef QUIET
+  if (ch < 0) return;
+  if (ch > 0) notified.push_back (ch);
+#else
+  if (ch < 0 && (!terminal || verbose)) return;
+  double t = absolute_real_time ();
+  if (ch > 0) notified.push_back (ch), progress_counter = 1;
+  else if (ch < 0) {
+    if (t < last_progress_time + 0.3) return;
+    progress_counter++;
+  }
+#endif
+  if (!first || !(mode & OUTPUT))
+    terminal.erase_line_if_connected_otherwise_new_line ();
+  prefix ();
+  if (traces) cerr << ' ' << left << setw (12) << traces;
+  else cerr << left << setw (13) << "reduce:";
+  terminal.yellow ();
+
+  if (!notified.empty ()) {
+    for (size_t i = 0; i + 1 < notified.size (); i++)
+      cerr << notified[i];
+#ifndef QUIET
+    if (progress_counter & 1) terminal.inverse ();
+#else
+    terminal.inverse ();
+#endif
+    cerr << notified.back ();
+    terminal.normal ();
+  }
+
+  if (notified.size () < 45) cerr << setw (45 - notified.size ()) << " ";
+  cerr << flush;
+  summarize (trace);
+  if (verbose) cerr << endl;
+  cerr << flush;
+#ifndef QUIET
+  last_progress_time = t;
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+// Explicit grammar aware three-level hierarchical delta-debugging.
+// First level is in term of incremental solving phases where one phase
+// consists of maximal prefixes of intervals of calls of type
+// '(BEFORE*|PROCESS|AFTER*)' or single non-configuration calls.
+//
+bool Trace::shrink_phases (int expected) {
+  if (mobical.donot.shrink.phases) return false;
+  notify ('p');
+  size_t l;
+  for (l = 1; l < size () && config_type (calls[l]->type); l++)
+    ;
+  Segments segments;
+  size_t r;
+  for (; l < size (); l = r) {
+    for (r = l; r < size () && before_type (calls[r]->type); r++)
+      ;
+    if (r < size () && process_type (calls[r]->type)) r++;
+    for (;r < size () && after_type (calls[r]->type); r++)
+      ;
+    if (l < r) segments.push_back (Segment (l, r));
+    else {
+      assert (l == r);
+      if (!config_type (calls[r]->type))
+        segments.push_back (Segment (r, r + 1));
+      ++r;
+    }
+  }
+  return shrink_segments (segments, expected);
+}
+
+// The second level ties to remove clauses.
+//
+bool Trace::shrink_clauses (int expected) {
+  if (mobical.donot.shrink.clauses) return false;
+  notify ('c');
+  Segments segments;
+  for (size_t r = size (), l; r > 1; r = l) {
+    Call * c = calls[l = r - 1];
+    while (l > 0 && (c->type != Call::ADD || c->arg))
+      c = calls[--l];
+    if (!l) break;
+    r = l + 1;
+    while ((c = calls[--l])->type == Call::ADD && c->arg)
+      ;
+    segments.push_back (Segment (++l, r));
+  }
+  return shrink_segments (segments, expected);
+}
+
+// The third level tries to remove individual literals.
+//
+bool Trace::shrink_literals (int expected) {
+  if (mobical.donot.shrink.literals) return false;
+  notify ('l');
+  Segments segments;
+  for (size_t l = size ()-1; l > 0; l--) {
+    Call * c = calls[l];
+    if (c->type == Call::ADD && c->arg)
+      segments.push_back (Segment (l, l+1));
+  }
+  return shrink_segments (segments, expected);
+}
+
+static bool is_basic (Call * c) {
+  switch (c->type) {
+    case Call::ASSUME:
+    case Call::SOLVE:
+    case Call::SIMPLIFY:
+    case Call::LOOKAHEAD:
+    case Call::CUBING:
+    case Call::VARS:
+    case Call::ACTIVE:
+    case Call::REDUNDANT:
+    case Call::IRREDUNDANT:
+    case Call::RESERVE:
+    case Call::VAL:
+    case Call::FIXED:
+    case Call::FAILED:
+    case Call::FROZEN:
+    case Call::FREEZE:
+    case Call::MELT:
+    case Call::LIMIT:
+    case Call::OPTIMIZE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool Trace::shrink_basic (int expected) {
+  if (mobical.donot.shrink.basic) return false;
+  notify ('b');
+  Segments segments;
+  for (size_t l = size ()-1; l > 0; l--) {
+    Call * c = calls[l];
+    if (!is_basic (c)) continue;
+    segments.push_back (Segment (l, l+1));
+  }
+  return shrink_segments (segments, expected);
+}
+
+// We first add all non present possible options with their default value.
+
+void Trace::add_options (int expected) {
+  if (mobical.donot.add) return;
+  const int max_var = vars ();
+  notify ('a');
+  assert (size ());
+  assert (calls[0]->type == Call::INIT);
+  Trace extended;
+  extended.push_back (calls[0]->copy ());
+  size_t i = 1;
+  Call * c;
+  while (i < size () && (c = calls[i])->type == Call::SET)
+    extended.push_back (c->copy ()), i++;
+  for (Options::const_iterator it = Options::begin ();
+       it != Options::end ();
+       it++) {
+    const Option & o = *it;
+    if (find_option_by_name (o.name)) continue;
+    if (ignore_option (o.name, max_var)) continue;
+    if (extended.ignore_option (o.name, max_var)) continue;
+    extended.push_back (new SetCall (o.name, o.def));
+  }
+  while (i < size ())
+    extended.push_back (calls[i++]->copy ());
+  progress ();
+  if (extended.fork_and_execute () != expected) return;
+  clear ();
+  for (i = 0; i < extended.size (); i++)
+    push_back (extended[i]->copy ());
+  notify ();
+}
+
+// Try to set as many options to their lower limit, which also tries to
+// disable as many boolean options.
+
+bool Trace::shrink_disable (int expected) {
+
+  if (mobical.donot.disable) return false;
+  const int max_var = vars ();
+
+  notify ('d');
+  size_t last = last_option ();
+  vector<size_t> candidates;
+  vector<int> lower, saved;
+  for (size_t i = first_option (); i < last; i++) {
+    Call * c = calls[i];
+    if (c->type != Call::SET) continue;
+    if (ignore_option (c->name, max_var)) continue;
+    Option * o = Options::has (c->name);
+    if (!o) continue;
+    if (c->val == o->lo) continue;
+    candidates.push_back (i);
+    lower.push_back (o->lo);
+    saved.push_back (c->val);
+  }
+  if (candidates.empty ()) return false;
+  size_t granularity = candidates.size ();
+  bool res = false;
+  for (;;) {
+    size_t n = candidates.size ();
+    for (size_t i = 0; i < n; i += granularity) {
+      bool reduce = false;
+      for (size_t j = i; j < n && j < i + granularity; j++) {
+        size_t k = candidates[j];
+        Call * c = calls[k];
+        assert (c->type == Call::SET);
+        saved[j] = c->val;
+        int new_val = lower[j];
+        if (c->val == new_val) continue;
+        c->val = new_val;
+        reduce = true;
+      }
+      if (!reduce) continue;
+      progress ();
+      if (fork_and_execute () == expected) res = true;
+      else {
+        for (size_t j = i; j < n && j < i + granularity; j++) {
+          size_t k = candidates[j];
+          Call * c = calls[k];
+          assert (c->type == Call::SET);
+          c->val = saved[j];
+        }
+      }
+    }
+    if (granularity == 1) break;
+    granularity = (granularity + 1)/2;
+  }
+  notify ();
+  return res;
+}
+
+// Try to shrink the option values.
+
+bool Trace::reduce_values (int expected) {
+
+  if (mobical.donot.reduce) return false;
+
+  notify ('r');
+
+  assert (size ());
+  assert (calls[0]->type == Call::INIT);
+
+  bool changed = false, res = false;
+  do {
+    if (changed) res = true;
+    changed = false;
+    for (size_t i = 0; i < size (); i++) {
+      Call * c = calls[i];
+
+      int lo, hi;
+
+      if (c->type == Call::SET) {
+        Option * o = Options::has (c->name);
+        if (!o) continue;
+        lo = o->lo, hi = o->hi;
+      } else if (c->type == Call::LIMIT) {
+        if (!strcmp (c->name, "conflicts") ||
+            !strcmp (c->name, "decisions"))
+          lo = -1, hi = INT_MAX;
+        else if (!strcmp (c->name, "terminate") ||
+                 !strcmp (c->name, "preprocessing"))
+          lo = 0, hi = INT_MAX;
+        else if (!strcmp (c->name, "localsearch"))
+          lo = 0, hi = c->val; // too costly otherwise
+        else continue;
+      } else if (c->type == Call::OPTIMIZE) {
+        lo = 0, hi = 9;
+      } else continue;
+
+      assert (lo <= hi);
+      if (c->val == lo) continue;
+
+      // First try to reach eagerly the low value
+      // (includes the case that current value is too low).
+      //
+      int old_val = c->val;
+      c->val = lo;
+      progress ();
+      if (fork_and_execute () == expected) {
+        assert (c->val != old_val);
+        changed = true;
+        continue;
+      }
+      c->val = old_val;
+
+      // Then try to limit to the high value if current value too large.
+      //
+      if (c->val > hi) {
+        int old_val = c->val;
+        c->val = hi;
+        progress ();
+        if (fork_and_execute () == expected) {
+          assert (c->val != old_val);
+          changed = true;
+        } else { c->val = old_val; continue; }
+      }
+
+      // Now we do a delta-debugging inspired binary search for the smallest
+      // value for which the execution produces a non-zero exit code.  It
+      // kind of assumes monotonicity and if this is not the case might not
+      // yield the smallest value, but remains logarithmic.
+      //
+      int64_t granularity = ((old_val - (int64_t) lo) + 1l) / 2;
+      assert (granularity > 0);
+      for (int64_t new_val = c->val - granularity;
+           new_val > lo;
+           new_val -= granularity) {
+        old_val = c->val;
+        assert (new_val != old_val);
+        assert (lo < new_val);
+        assert (new_val <= hi);
+        c->val = new_val;
+        progress ();
+        if (fork_and_execute () == expected) {
+          assert (c->val != old_val);
+          changed = true;
+        } else c->val = old_val;
+      }
+    }
+  } while (changed);
+
+  notify ();
+
+  return res;
+}
+
+static bool has_lit_arg_type (Call * c) {
+  switch (c->type) {
+    case Call::ADD:
+    case Call::ASSUME:
+    case Call::FREEZE:
+    case Call::MELT:
+    case Call::FROZEN:
+    case Call::VAL:
+    case Call::FIXED:
+    case Call::FAILED:
+    case Call::RESERVE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// Try to map variables to a contiguous initial range.
+
+void Trace::map_variables (int expected) {
+  if (mobical.donot.map) return;
+  for (int with_gaps = 0; with_gaps <= 1; with_gaps++) {
+    notify ('m');
+    vector<int> variables;
+    for (size_t i = 0; i < size (); i++) {
+      Call * c = calls[i];
+      if (!has_lit_arg_type (c)) continue;
+      if (!c->arg) continue;
+      if (c->arg == INT_MIN) continue;
+      int idx = abs (c->arg);
+      while (variables.size () <= (size_t) idx)
+        variables.push_back (0);
+      variables[idx]++;
+    }
+    int gaps = 0, max_idx = 0;
+    bool skipped = false;
+    for (int i = 1; (size_t) i < variables.size (); i++) {
+      if (!variables[i]) {
+        if (with_gaps && !skipped) max_idx++, skipped = true;
+        gaps++;
+      } else {
+        variables[i] = ++max_idx;
+        skipped = false;
+      }
+    }
+    if (!gaps) { notify (); return; }
+    Trace mapped;
+    for (size_t i = 0; i < size (); i++) {
+      Call * c = calls[i];
+      if (!c->arg || c->arg == INT_MIN)
+        mapped.push_back (c->copy ());
+      else if (has_lit_arg_type (c)) {
+        int new_lit = variables[abs (c->arg)];
+        assert (0 < new_lit), assert (new_lit <= max_idx);
+        if (c->arg < 0) new_lit = -new_lit;
+        Call * d = c->copy ();
+        d->arg = new_lit;
+        mapped.push_back (d);
+      } else mapped.push_back (c->copy ());
+    }
+    progress ();
+    if (mapped.fork_and_execute () == expected) {
+      clear ();
+      for (size_t i = 0; i < mapped.size (); i++)
+        push_back (mapped[i]->copy ());
+      notify ();
+      with_gaps = 2;
+    }
+    notify ();
+  }
+}
+
+// Finally remove option calls.
+
+void Trace::shrink_options (int expected) {
+
+  if (mobical.donot.shrink.options) return;
+
+  notify ('o');
+  Segments segments;
+  for (size_t i = 0; i < size (); i++) {
+    Call * c = calls[i];
+    if (c->type != Call::SET) continue;
+    segments.push_back (Segment (i, i+1));
+  }
+
+  (void) shrink_segments (segments, expected);
+}
+
+void Trace::shrink (int expected) {
+
+  enum Shrinking {
+    NONE = 0,
+    PHASES,
+    CLAUSES,
+    LITERALS,
+    BASIC,
+    DISABLE,
+    VALUES
+  };
+
+  mobical.shrinking = true;
+  mobical.notified.clear ();
+  assert (!mobical.donot.shrink.atall);
+  if (!size () || calls[0]->type != Call::INIT) return;
+  add_options (expected);
+  Shrinking l = NONE;
+  bool s;
+  do {
+    s = false;
+    if (l != PHASES && shrink_phases (expected))     s = true, l = PHASES;
+    if (l != CLAUSES && shrink_clauses (expected))   s = true, l = CLAUSES;
+    if (l != LITERALS && shrink_literals (expected)) s = true, l = LITERALS;
+    if (l != BASIC && shrink_basic (expected))       s = true, l = BASIC;
+    if (l != DISABLE && shrink_disable (expected))   s = true, l = DISABLE;
+    if (l != VALUES && reduce_values (expected))     s = true, l = VALUES;
+  } while (s);
+  map_variables (expected);
+  shrink_options (expected);
+  cerr << flush;
+  mobical.shrinking = false;
+}
+
+void Trace::write_path (const char * path) {
+  if (!strcmp (path, "-")) print (cout);
+  else {
+    ofstream os (path);
+    if (!os.is_open ())
+      mobical.die ("can not write '%s'", path);
+    print (os);
+  }
+}
+
+void Trace::write_prefixed_seed (const char * prefix) {
+  ostringstream ss;
+  ss << prefix << '-'
+     << setfill ('0') << right << setw (20) << seed
+     << ".trace" << flush;
+  ofstream os (ss.str ().c_str ());
+  if (!os.is_open ())
+    mobical.die ("can not write '%s'", ss.str ().c_str ());
+  print (os);
+  cerr << ss.str ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Reader::error (const char * fmt, ...) {
+  mobical.error_prefix ();
+  mobical.terminal.red (true);
+  fputs ("parse error:", stderr);
+  mobical.terminal.normal ();
+  fprintf (stderr, " %s:%d: ", path, lineno);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  mobical.terminal.reset ();
+  exit (1);
+}
+
+static bool is_valid_char (int ch) {
+  if (ch == ' ') return true;
+  if (ch == '-') return true;
+  if ('a' <= ch && ch <= 'z') return true;
+  if ('0' <= ch && ch <= '9') return true;
+  return false;
+}
+
+void Reader::parse () {
+  int ch, lit = 0, val = 0, state = 0, adding = 0, solved = 0;
+  const bool enforce = !mobical.donot.enforce;
+  Call * before_trigger = 0;
+  char line[80];
+  while ((ch = next ()) != EOF) {
+    size_t n = 0;
+    while (ch != '\n') {
+      if (n + 2 >= sizeof line) error ("line too large");
+      if (!is_valid_char (ch)) {
+        if (isprint (ch)) error ("invalid character '%c'", ch);
+        else error ("invalid character code 0x%02x", ch);
+      }
+      line[n++] = ch;
+      if ((ch = next ()) == EOF) error ("unexpected end-of-file");
+    }
+    assert (n < sizeof line);
+    line[n] = 0;
+    char * p = line;
+    if (isdigit (ch = *p)) {
+      while (isdigit (ch = *++p))
+        ;
+      if (!ch) error ("incomplete line with only line number");
+      if (ch != ' ') error ("expected space after line number");
+      p++;
+    }
+    const char * keyword = p;
+    if ((ch = *p) < 'a' || 'z' < ch)
+      error ("expected keyword to start with lower case letter");
+    while (p < line + n && (ch = *++p) && 'a' <= ch && ch <= 'z')
+      ;
+    const char * first = 0, * second = 0;
+    if ((ch = *p) == ' ') {
+      *p++ = 0;
+      first = p;
+      ch = *p;
+      if (!ch) error ("first argument missing after trailing space");
+      if (ch == ' ') error ("space in place of first argument");
+      while ((ch = *++p) && ch != ' ')
+        ;
+      if (ch == ' ') {
+        *p++ = 0;
+        second = p;
+        ch = *p;
+        if (!ch) error ("second argument missing after trailing space");
+        if (ch == ' ') error ("space in place of second argument");
+        while ((ch = *++p) && ch != ' ')
+          ;
+        if (ch == ' ') {
+          *p = 0;
+          error ("unexpected space after second argument '%s'", second);
+        }
+      }
+    } else if (ch) error ("unexpected character '%c' in keyword", ch);
+    assert (!ch);
+    Call * c = 0;
+    if (!strcmp (keyword, "init")) {
+      if (first) error ("unexpected argument '%s' after 'init'", first);
+      c = new InitCall ();
+    } else if (!strcmp (keyword, "set")) {
+      if (!first) error ("first argument to 'set' missing");
+      if (enforce && !Solver::is_valid_option ((first))) {
+#ifndef LOGGING
+        if (!strcmp (first, "log"))
+          mobical.warning (
+            "non-existing option name 'log' "
+            "(compiled without '-DLOGGING')");
+        else
+#endif
+        error ("non-existing option name '%s'", first);
+      }
+      if (!second) error ("second argument to 'set' missing");
+      if (!parse_int_str (second, val))
+        error ("invalid second argument '%s' to 'set'", second);
+      c = new SetCall (first, val);
+    } else if (!strcmp (keyword, "configure")) {
+      if (!first) error ("first argument to 'configure' missing");
+      if (enforce && !Solver::is_valid_configuration (first))
+        error ("non-existing configuration '%s'", first);
+      if (second) error ("additional argument '%s' to 'configure'", second);
+      c = new ConfigureCall (first);
+    } else if (!strcmp (keyword, "limit")) {
+      if (!first) error ("first argument to 'limit' missing");
+      if (!second) error ("second argument to 'limit' missing");
+      if (!parse_int_str (second, val))
+        error ("invalid second argument '%s' to 'limit'", second);
+      c = new LimitCall (first, val);
+    } else if (!strcmp (keyword, "optimize")) {
+      if (!first) error ("argument to 'optimize' missing");
+      if (!parse_int_str (first, val) || val < 0 || val > 31)
+        error ("invalid argument '%s' to 'optimize'", first);
+      c = new OptimizeCall (val);
+    } else if (!strcmp (keyword, "vars")) {
+      if (first) error ("unexpected argument '%s' after 'vars'", first);
+      c = new VarsCall ();
+    } else if (!strcmp (keyword, "active")) {
+      if (first) error ("unexpected argument '%s' after 'active'", first);
+      c = new ActiveCall ();
+    } else if (!strcmp (keyword, "redundant")) {
+      if (first)
+        error ("unexpected argument '%s' after 'redundant'", first);
+      c = new RedundantCall ();
+    } else if (!strcmp (keyword, "irredundant")) {
+      if (first)
+        error ("unexpected argument '%s' after 'irredundant'", first);
+      c = new IrredundantCall ();
+    } else if (!strcmp (keyword, "reserve")) {
+      if (!first) error ("argument to 'reserve' missing");
+      if (!parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'reserve'", first);
+      if (second) error ("additional argument '%s' to 'reserve'", second);
+      c = new ReserveCall (lit);
+    } else if (!strcmp (keyword, "add")) {
+      if (!first) error ("argument to 'add' missing");
+      if (!parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'add'", first);
+      if (second) error ("additional argument '%s' to 'add'", second);
+      if (enforce && lit == INT_MIN)
+        error ("invalid literal '%d' as argument to 'add'", lit);
+      adding = lit;
+      c = new AddCall (lit);
+    } else if (!strcmp (keyword, "assume")) {
+      if (!first) error ("argument to 'assume' missing");
+      if (!parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'assume'", first);
+      if (second)
+        error ("additional argument '%s' to 'assume'", second);
+      if (enforce && (!lit || lit == INT_MIN))
+        error ("invalid literal '%d' as argument to 'assume'", lit);
+      c = new AssumeCall (lit);
+    } else if (!strcmp (keyword, "solve")) {
+      if (first && !parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'solve'", first);
+      if (first && lit != 0 && lit != 10 && lit != 20)
+        error ("invalid result argument '%d' to 'solve'", lit);
+      assert (!second);
+      if (first) c = new SolveCall (lit);
+      else       c = new SolveCall ();
+      solved++;
+    } else if (!strcmp (keyword, "simplify")) {
+      if (!first)
+        error ("argument to 'simplify' missing");
+      int rounds;
+      if (!parse_int_str (first, rounds) || rounds < 0)
+        error ("invalid argument '%s' to 'simplify'", first);
+      int tmp;
+      if (second && !parse_int_str (second, tmp))
+        error ("invalid second argument '%s' to 'simplify'", second);
+      if (second && tmp != 0 && tmp != 10 && tmp != 20)
+        error ("invalid second argument '%d' to 'solve'", tmp);
+      if (second) c = new SimplifyCall (rounds, tmp);
+      else        c = new SimplifyCall (rounds);
+      solved++;
+    } else if (!strcmp (keyword, "lookahead")) {
+      if (first && !parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'lookahead'", first);
+      assert (!second);
+      if (first) c = new LookaheadCall (lit);
+      else       c = new LookaheadCall ();
+      solved++;
+    }  else if (!strcmp (keyword, "cubing")) {
+      if (first && !parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'cubing'", first);
+      assert (!second);
+      c = new CubingCall (lit);
+      solved++;
+    } else if (!strcmp (keyword, "val")) {
+      if (!first) error ("first argument to 'val' missing");
+      if (!parse_int_str (first, lit))
+        error ("invalid first argument '%s' to 'val'", first);
+      if (enforce && (!lit || lit == INT_MIN))
+        error ("invalid literal '%d' as argument to 'val'", lit);
+      if (second && !parse_int_str (second, val))
+        error ("invalid second argument '%s' to 'val'", second);
+      if (second && val != -1 && val != 0 && val != -1)
+        error ("invalid result argument '%d' to 'val", val);
+      if (second) c = new ValCall (lit, val);
+      else        c = new ValCall (lit);
+    } else if (!strcmp (keyword, "fixed")) {
+      if (!first) error ("first argument to 'fixed' missing");
+      if (!parse_int_str (first, lit))
+        error ("invalid first argument '%s' to 'fixed'", first);
+      if (enforce && (!lit || lit == INT_MIN))
+        error ("invalid literal '%d' as argument to 'fixed'", lit);
+      if (second && !parse_int_str (second, val))
+        error ("invalid second argument '%s' to 'fixed'", second);
+      if (second && val != -1 && val != 0 && val != -1)
+        error ("invalid result argument '%d' to 'fixed", val);
+      if (second) c = new FixedCall (lit, val);
+      else        c = new FixedCall (lit);
+    } else if (!strcmp (keyword, "failed")) {
+      if (!first) error ("first argument to 'failed' missing");
+      if (!parse_int_str (first, lit))
+        error ("invalid first argument '%s' to 'failed'", first);
+      if (enforce && (!lit || lit == INT_MIN))
+        error ("invalid literal '%d 'as argument to 'failed'", lit);
+      if (second && !parse_int_str (second, val))
+        error ("invalid second argument '%s' to 'failed'", second);
+      if (second && val != 0 && val != -1)
+        error ("invalid result argument '%d' to 'failed", val);
+      if (second) c = new FailedCall (lit, val);
+      else        c = new FailedCall (lit);
+    } else if (!strcmp (keyword, "freeze")) {
+      if (!first) error ("argument to 'freeze' missing");
+      if (!parse_int_str (first, lit))
+        error ("invalid argument '%s' to 'freeze'", first);
+      if (enforce && (!lit || lit == INT_MIN))
+        error ("invalid literal %d as argument to 'freeze'", lit);
+      if (second)
+        error ("additional argument '%s' to 'freeze'", second);
+      c = new FreezeCall (lit);
+    } else if (!strcmp (keyword, "melt")) {
+      if (!first) error("argument to 'melt' missing");
+    if (!parse_int_str(first, lit))
+      error("invalid argument '%s' to 'melt'", first);
+    if (enforce && (!lit || lit == INT_MIN))
+      error("invalid literal '%d' as argument to 'melt'", lit);
+    if (second)
+      error("additional argument '%s' to 'melt'", second);
+    c = new MeltCall(lit);
+  }
+  else if (!strcmp(keyword, "frozen")) {
+    if (!first)
+      error("first argument to 'frozen' missing");
+    if (!parse_int_str(first, lit))
+      error("invalid first argument '%s' to 'frozen'", first);
+    if (second && !parse_int_str(second, val))
+      error("invalid second argument '%s' to 'frozen'", second);
+    if (second && val != 0 && val != 1)
+      error("invalid result argument '%d' to 'frozen'", val);
+    if (second)
+      c = new FrozenCall(lit, val);
+    else
+      c = new FrozenCall(lit);
+  }
+  else if (!strcmp(keyword, "dump")) {
+    if (first)
+      error("additional argument '%s' to 'dump'", first);
+    c = new DumpCall();
+  }
+  else if (!strcmp(keyword, "stats")) {
+    if (first)
+      error("additional argument '%s' to 'stats'", first);
+    c = new StatsCall();
+  }
+  else if (!strcmp(keyword, "reset")) {
+    if (first)
+      error("additional argument '%s' to 'reset'", first);
+    c = new ResetCall();
+  }
+  else error("invalid keyword '%s'", keyword);
+
+  // This checks the legal structure of traces described above.
+  //
+  if (enforce) {
+
+    if (!state && c->type != Call::INIT)
+      error("first call has to be an 'init' call");
+
+    if (state == Call::RESET)
+      error("'%s' after 'reset'", c->keyword());
+
+    if (adding && c->type != Call::ADD && c->type != Call::RESET)
+      error("'%s' after 'add %d' without 'add 0'", c->keyword(), adding);
+
+    int new_state = state;
+
+    switch (c->type) {
+
+    case Call::INIT:
+      if (state)
+        error("invalid second 'init' call");
+      new_state = Call::CONFIG;
+      break;
+
+    case Call::SET:
+    case Call::CONFIGURE:
+      if (!solved && state == Call::BEFORE) {
+        assert(before_trigger);
+        error("'%s' can only be called after 'init' before '%s %d'",
+              c->keyword(), before_trigger->keyword(), before_trigger->arg);
+      } else if (state != Call::CONFIG)
+        error("'%s' can only be called right after 'init'", c->keyword());
+      assert(new_state == Call::CONFIG);
+      break;
+
+    case Call::ADD:
+    case Call::ASSUME:
+      if (state != Call::BEFORE)
+        before_trigger = c;
+      new_state = Call::BEFORE;
+      break;
+
+    case Call::VAL:
+    case Call::FAILED:
+      if (!solved && (state == Call::CONFIG || state == Call::BEFORE))
+        error("'%s' can only be called after 'solve'", c->keyword());
+      if (solved && state == Call::BEFORE) {
+        assert(before_trigger);
+        error("'%s' only valid after last 'solve' and before '%s %d'",
+              c->keyword(), before_trigger->keyword(), before_trigger->arg);
+      }
+      assert(state == Call::SOLVE || state == Call::SIMPLIFY ||
+             state == Call::LOOKAHEAD || state == Call::CUBING ||
+             state == Call::AFTER);
+      new_state = Call::AFTER;
+      break;
+
+    case Call::SOLVE:
+    case Call::SIMPLIFY:
+    case Call::LOOKAHEAD:
+    case Call::CUBING:
+    case Call::RESET:
+      new_state = c->type;
+      break;
+
+    default:
+      break;
+    }
+
+    state = new_state;
+    }
+
+#ifdef LOGGING
+    if (trace.size () == 1 && mobical.add_set_log_to_true)
+      trace.push_back (new SetCall ("log", 1));
+#endif
+
+    if (c && mobical.add_dump_before_solve && process_type (c->type))
+      trace.push_back (new DumpCall ());
+
+    trace.push_back (c);
+
+    if (c && mobical.add_stats_after_solve && process_type (c->type))
+      trace.push_back (new StatsCall ());
+
+    lineno++;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Mobical::is_unsigned_str (const char * str) {
+  const char * p = str;
+  if (!*p) return false;
+  if (!isdigit (*p++)) return false;
+  while (isdigit (*p)) p++;
+  return !*p;
+}
+
+uint64_t Mobical::parse_seed (const char * str) {
+  const uint64_t max = ~ (uint64_t) 0;
+  uint64_t res = 0;
+  for (const char * p = str; *p; p++) {
+    if (max/10 < res)
+      die ("invalid seed '%s' (too many digits)", str);
+    res *= 10;
+    assert (isdigit (*p));
+    unsigned digit = *p - '0';
+    if (max - digit < res)
+      die ("invalid seed '%s' (too large)", str);
+    res += digit;
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Mobical::header () {
+  terminal.blue ();
+  cerr << "calls";
+  terminal.magenta ();
+  cerr << " vars";
+  terminal.yellow ();
+  cerr << " clauses";
+  terminal.normal ();
+}
+
+/*------------------------------------------------------------------------*/
+
+extern "C" {
+#include <sys/mman.h>
+}
+
+Mobical::Mobical ()
+:
+  mode (0),
+  verbose (false),
+#ifdef LOGGING
+  add_set_log_to_true (false),
+#endif
+  add_dump_before_solve (false),
+  add_stats_after_solve (false),
+  shrinking (false),
+  running (false),
+  time_limit (DEFAULT_TIME_LIMIT),
+  space_limit (DEFAULT_SPACE_LIMIT),
+  terminal (terr),
+#ifndef QUIET
+  progress_counter (0),
+  last_progress_time (0),
+#endif
+  traces (0),
+  spurious (0)
+{
+  const int prot = PROT_READ | PROT_WRITE;
+  const int flags = MAP_ANONYMOUS | MAP_SHARED;
+  shared = (Shared*) mmap (0, sizeof *shared, prot, flags, 0, 0);
+}
+
+Mobical::~Mobical () {
+  if (shared) munmap (shared, sizeof *shared);
+}
+
+void Mobical::catch_signal (int) {
+  if ((terminal && (mode & RANDOM)) || shrinking || running)
+    cerr << endl;
+  terminal.reset ();
+  if (Trace::executed && !Trace::failed && !Trace::ok)
+    assert (mode & (INPUT | SEED)), Trace::failed = 1;
+  print_statistics ();
+}
+
+/*------------------------------------------------------------------------*/
+
+int Mobical::main (int argc, char ** argv) {
+
+  // First parse command line options and determine mode.
+  //
+  const char * seed_str = 0;
+  const char * input_path = 0;
+  const char * output_path = 0;
+
+  int64_t limit = -1;
+
+  // Error message in 'die' also uses colors.
+  //
+  for (int i = 1; i < argc; i++)
+    if (is_color_option (argv[i]))
+      tout.force_colors (), terr.force_colors ();
+    else if (is_no_color_option (argv[i]))
+      terminal.force_no_colors ();
+    else if (!strcmp (argv[i], "--no-terminal"))
+      terminal.disable ();
+
+  for (int i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h")) {
+       printf (USAGE, DEFAULT_TIME_LIMIT, DEFAULT_SPACE_LIMIT);
+       exit (0);
+    } else if (!strcmp (argv[i], "--version"))
+      puts (version ()), exit (0);
+    else if (!strcmp (argv[i], "--build")) {
+      tout.disable ();
+      Solver::build (stdout, "");
+      exit (0);
+    } else if (!strcmp (argv[i], "-v")) verbose = true;
+    else if (is_color_option (argv[i]))
+      ;
+    else if (is_no_color_option (argv[i]))
+      ;
+    else if (!strcmp (argv[i], "--no-terminal"))
+      assert (!terminal);
+    else if (!strcmp (argv[i], "--do-not-execute"))
+      donot.execute = true;
+    else if (!strcmp (argv[i], "--do-not-fork"))
+      donot.fork = true;
+    else if (!strcmp (argv[i], "--do-not-enforce-contracts"))
+      donot.enforce = true;
+    else if (!strcmp (argv[i], "--no-seeds"))
+      donot.seeds = true;
+    else if (!strcmp (argv[i], "--do-not-shrink") ||
+             !strcmp (argv[i], "--do-not-shrink-at-all"))
+      donot.shrink.atall = true;
+    else if (!strcmp (argv[i], "--do-not-add-options") ||
+             !strcmp (argv[i], "--do-not-add-options-before-shrinking"))
+      donot.add = true;
+    else if (!strcmp (argv[i], "--do-not-shrink-phases"))
+      donot.shrink.phases = true;
+    else if (!strcmp (argv[i], "--do-not-shrink-clauses"))
+      donot.shrink.clauses = true;
+    else if (!strcmp (argv[i], "--do-not-shrink-literals"))
+      donot.shrink.literals = true;
+    else if (!strcmp (argv[i], "--do-not-shrink-basic") ||
+             !strcmp (argv[i], "--do-not-shrink-basic-calls"))
+      donot.shrink.basic = true;
+    else if (!strcmp (argv[i], "--do-not-shrink-options"))
+      donot.shrink.options = true;
+    else if (!strcmp (argv[i], "--do-not-disable") ||
+             !strcmp (argv[i], "--do-not-disable-options"))
+      donot.disable = true;
+    else if (!strcmp (argv[i], "--do-not-shrink-variables"))
+      donot.map = true;
+    else if (!strcmp (argv[i], "--do-not-reduce") ||
+             !strcmp (argv[i], "--do-not-reduce-values") ||
+             !strcmp (argv[i], "--do-not-reduce-option-values"))
+      donot.reduce = true;
+    else if (!strcmp (argv[i], "--small")) force.size = SMALL;
+    else if (!strcmp (argv[i], "--medium")) force.size = MEDIUM;
+    else if (!strcmp (argv[i], "--big")) force.size = BIG;
+    else if (!strcmp (argv[i], "-l") || !strcmp (argv[i], "--log")) {
+#ifdef LOGGING
+      add_set_log_to_true = true;
+#else
+      die ("can not force logging with '%s' (compiled without '-DLOGGING')",
+        argv[i]);
+#endif
+    } else if (!strcmp (argv[i], "-d") || !strcmp (argv[i], "--dump")) {
+      add_dump_before_solve = true;
+    } else if (!strcmp (argv[i], "-s") || !strcmp (argv[i], "--stats")) {
+      add_stats_after_solve = true;
+    } else if (!strcmp (argv[i], "-L")) {
+      if (limit >= 0) die ("multiple '-L' options (try '-h')");
+      if (++i == argc) die ("argument to '-L' missing (try '-h')");
+      if (!is_unsigned_str (argv[i]) || (limit = atol (argv[i])) < 0)
+        die ("invalid argument '%s' to '-L' (try '-h')", argv[i]);
+    } else if (!strcmp (argv[i], "--time")) {
+      if (++i == argc) die ("argument to '--time' missing (try '-h')");
+      if (!is_unsigned_str (argv[i]) ||
+          (time_limit = atol (argv[i])) < 0 || time_limit > 1e9)
+        die ("invalid argument '%s' to '--time' (try '-h')", argv[i]);
+    } else if (!strcmp (argv[i], "--space")) {
+      if (++i == argc) die ("argument to '--space' missing (try '-h')");
+      if (!is_unsigned_str (argv[i]) ||
+          (space_limit = atol (argv[i])) < 0 || space_limit > 1e9)
+        die ("invalid argument '%s' to '--space' (try '-h')", argv[i]);
+    } else if (!strcmp (argv[i], "--do-not-ignore-resource-limits")) {
+      donot.ignore_resource_limits = true;
+    } else if (argv[i][0] == '-' && is_unsigned_str (argv[i] + 1)) {
+      force.phases = atoi (argv[i] + 1);
+      if (force.phases < 0)
+        die ("invalid number of phases '%s'", argv[i]);
+    } else if (argv[i][0] == '-' && argv[i][1])
+      die ("invalid option '%s' (try '-h')", argv[i]);
+    else if (is_unsigned_str (argv[i])) {
+      if (seed_str)
+        die ("can not handle multiple seeds '%s' and '%s' (try '-h')",
+          seed_str, argv[i]);
+      if (input_path)
+        die ("can not combine input trace '%s' and seed '%s' (try '-h')",
+          input_path, argv[i]);
+      seed_str = argv[i];
+    } else if (output_path) {
+      assert (input_path);
+      die ("too many trace files specified: '%s', '%s' and '%s' (try '-h')",
+        input_path, output_path, argv[i]);
+    } else if (input_path) {
+      if (seed_str)
+        die ("seed '%s' with two output files '%s' and '%s' ",
+          seed_str, input_path, argv[i]);
+      if (strcmp (input_path, "-") && !strcmp (input_path, argv[i]))
+        die ("input '%s' and output '%s' are the same",
+          input_path, argv[i]);
+      output_path = argv[i];
+    } else {
+      if (!seed_str && strcmp (argv[i], "-") && !File::exists (argv[i]))
+        die ("can not access input trace '%s' (try '-h')", argv[i]);
+      input_path = argv[i];
+    }
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  // If a seed and a file (in that order) are specified the file is actually
+  // not an input file but an output file.  To streamline the code below
+  // swap input and output here.
+  //
+  if (input_path && seed_str) {
+    assert (!output_path);
+    output_path = input_path;
+    input_path = 0;
+  }
+
+  if (output_path && !File::writable (output_path))
+    die ("can not write output trace '%s' (try '-h')", output_path);
+
+  /*----------------------------------------------------------------------*/
+
+  // Check illegal combinations of options.
+
+  if (input_path && donot.seeds)
+    die ("can not use '--no-seeds' while specifying input '%s' explicitly",
+      input_path);
+
+  if (input_path && limit >= 0)
+    die ("can not combine '-L' and input '%s'", input_path);
+
+  if (output_path && limit >= 0)
+    die ("can not combine '-L' and output '%s'", output_path);
+
+  if (!output_path && donot.execute)
+    die ("can not use '--do-no-execute' without '<output>'");
+
+  if (!input_path && donot.enforce)
+    die ("can not use '--do-not-enforce-contracts' without '<input>'");
+
+  if (output_path && donot.enforce)
+    die ("can not use '--do-not-enforce-contracts' "
+      "with both '<input>' and '<output>'");
+
+  /*----------------------------------------------------------------------*/
+
+  // Set mode.
+
+  if (limit >= 0)               mode = RANDOM;
+  else {
+    if (seed_str || input_path) mode = 0;
+    else                        mode = RANDOM;
+    if (seed_str)               mode |= SEED;
+    if (input_path)             mode |= INPUT;
+    if (output_path)            mode |= OUTPUT;
+  }
+  check_mode_valid ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Print banner.
+
+  prefix ();
+  terminal.magenta (1);
+  fputs ("Model Based Tester for the CaDiCaL SAT Solver Library\n", stderr);
+  terminal.normal ();
+  prefix ();
+  terminal.magenta (1);
+  fputs ("Copyright (c) 2018-2021 Armin Biere, Mathias Fleury, JKU Linz\n",
+         stderr);
+  terminal.normal ();
+  empty_line ();
+  Solver::build (stderr, prefix_string ());
+  terminal.normal ();
+  empty_line ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Print resource limits (per executed trace).
+
+  prefix ();
+  if (mobical.donot.fork)
+    cerr << "not using any time limit due to '--do-not-fork'";
+  else if (time_limit == DEFAULT_TIME_LIMIT)
+    cerr << "using default time limit of "
+         << time_limit << " seconds";
+  else if (time_limit)
+    cerr << "using explicitly specified time limit of "
+         << time_limit << " seconds";
+  else
+    cerr << "explicitly using no time limit";
+  cerr << endl << flush;
+
+  prefix ();
+  if (mobical.donot.fork)
+    cerr << "not using any space limit due to '--do-not-fork'";
+  else if (space_limit == DEFAULT_SPACE_LIMIT)
+    cerr << "using default space limit of "
+         << space_limit << " MB";
+  else if (space_limit)
+    cerr << "using explicitly specified space limit of "
+         << space_limit << " MB";
+  else
+    cerr << "explicitly using no space limit";
+  cerr << endl << flush;
+
+  /*----------------------------------------------------------------------*/
+
+  // Report mode.
+
+  if (mode & RANDOM) {
+    prefix ();
+    if (limit >= 0)
+      cerr << "randomly generating " << limit << " traces" << endl;
+    else {
+      cerr << "randomly generating traces";
+      if (terminal) {
+        terminal.magenta ();
+        cerr << " (press ";
+        terminal.blue ();
+        cerr << "'<control-c>'";
+        terminal.magenta ();
+        cerr << " to stop)";
+        terminal.normal ();
+      }
+      cerr << endl;
+    }
+    empty_line ();
+  }
+  if (mode & SEED) {
+    assert (seed_str);
+    prefix ();
+    cerr << "generating single trace from seed '"
+         << seed_str << '\'' << endl;
+  }
+  if (mode & INPUT) {
+    assert (input_path);
+    prefix ();
+    cerr << "reading single trace from input '"
+         << input_path << '\'' << endl;
+  }
+  if (mode & OUTPUT) {
+    assert (output_path);
+    prefix ();
+    cerr << "writing "
+         << (donot.shrink.atall ? "original" : "shrunken")
+         << " trace to output '"
+         << output_path << '\'' << endl;
+  }
+  cerr << flush;
+
+  /*----------------------------------------------------------------------*/
+
+  Signal::set (this);
+
+  int res = 0;
+
+  if (mode & (SEED | INPUT)) {   // trace given through input or seed
+
+    prefix ();
+    cerr << right << setw (58) << "";
+    header ();
+    cerr << endl;
+    hline ();
+
+    Trace trace;
+
+    if (seed_str) {                                     // seed
+
+      prefix ();
+      cerr << left << setw (13) << "seed:";
+      assert (is_unsigned_str (seed_str));
+      uint64_t seed = parse_seed (seed_str);
+      terminal.green ();
+      cerr << setfill ('0') << right << setw (20) << seed;
+      terminal.normal ();
+      cerr << setfill (' ') << setw (24) << "";
+      Trace::generated++;
+
+      trace.generate (0, seed);
+
+    } else {                                            // input
+
+      Reader reader (*this, trace, input_path);
+      reader.parse ();
+
+      prefix ();
+      cerr << left << setw (13) << "input: ";
+      assert (input_path);
+      cerr << left << setw (44) << input_path;
+    }
+
+    cerr << ' ';
+    summarize (trace);
+    cerr << endl << flush;
+
+    if (output_path) {
+
+      if (!donot.execute) {
+
+        res = trace.fork_and_execute ();
+        if (res) {
+          res = trace.fork_and_execute ();
+          if (!res) spurious++;
+        }
+
+        if (res) {
+
+          terminal.cursor (false);
+
+          Trace::failed++;
+          trace.shrink (res);                           // shrink
+          if (!verbose && !terminal) cerr << endl;
+          else terminal.erase_line_if_connected_otherwise_new_line ();
+
+        } else Trace::ok++;
+      }
+
+      prefix ();
+      cerr << left << setw (13) << "output:";
+
+      trace.write_path (output_path);                   // output
+
+      if (res) terminal.red (true);
+      cerr << left << setw (44);
+      if (!strcmp (output_path, "-")) cerr << "<stdout>";
+      else                            cerr << output_path;
+      terminal.normal ();
+      cerr << ' ';
+      summarize (trace);
+      cerr << endl << flush;
+
+    } else {
+      trace.execute ();                         // execute
+      Trace::ok++;
+    }
+
+  } else {             // otherwise generate random traces forever
+
+    Random random;          // initialized by time and machine id
+
+    if (seed_str) {
+      uint64_t seed = parse_seed (seed_str);
+      terminal.green ();
+      random = seed;
+    }
+
+    prefix ();
+    cerr << "start seed ";
+    terminal.green ();
+    cerr << random.seed ();
+    terminal.normal ();
+    cerr << endl;
+    empty_line ();
+
+    if (limit < 0) limit = LONG_MAX;
+
+    prefix ();
+    cerr << left << setw (14) << "count";
+    terminal.green ();
+    cerr << "seed";
+    terminal.black ();
+    cerr << '/';
+    terminal.red ();
+    cerr << "buggy";
+    terminal.black ();
+    cerr << '/';
+    terminal.yellow ();
+    cerr << "reducing";
+    terminal.black ();
+    cerr << '/';
+    terminal.red (true);
+    cerr << "reduced";
+    cerr << left << setw (17) << "";
+    header ();
+    cerr << endl;
+    hline ();
+
+    terminal.cursor (false);
+
+    for (traces = 1; traces <= limit ; traces++) {
+
+      if (!donot.seeds) {
+        prefix ();
+        cerr << ' ' << left << setw (15) << traces << ' ';
+        terminal.green ();
+        cerr << setfill ('0') << right << setw (20) << random.seed ();
+        terminal.normal ();
+        cerr << setfill (' ') << flush;
+      }
+
+      Trace trace;
+      Trace::generated++;
+      trace.generate (traces, random.seed ());          // generate
+
+      if (!donot.seeds) {
+        cerr << setw (21) << "";
+        summarize (trace);
+        terminal.erase_until_end_of_line ();
+        cerr << flush;
+      }
+
+      running = true;
+      res = trace.fork_and_execute ();                  // execute
+      if (res) {
+        res = trace.fork_and_execute ();
+        if (!res) spurious++;
+      }
+      if (res) Trace::failed++; else Trace::ok++;
+
+      if (!donot.seeds)
+        terminal.erase_line_if_connected_otherwise_new_line ();
+
+      if (res) {                                        // failed
+
+        prefix ();
+        cerr << ' ' << left << setw (11) << traces << ' ';
+        terminal.red ();
+        trace.write_prefixed_seed ("bug");              // output
+        terminal.normal ();
+        cerr << setw (15) << "";
+        summarize (trace);
+        if (terminal) cerr << endl << flush;
+        running = false;
+
+        if (!donot.shrink.atall) {
+          trace.shrink (res);                           // shrink
+          if (!terminal && !verbose) cerr << endl;
+          else terminal.erase_line_if_connected_otherwise_new_line ();
+        }
+
+        prefix ();
+        cerr << ' ' << left << setw (11) << traces << ' ';
+
+        terminal.red (true);
+        trace.write_prefixed_seed ("red");              // output
+        terminal.normal ();
+        cerr << setw (15) << "";
+        summarize (trace, true);
+        cerr << endl << flush;
+      }
+
+      random.next ();
+    }
+
+  }
+
+  Signal::reset ();
+
+  terminal.reset ();
+  print_statistics ();
+
+  return Trace::failed > 0;
+}
+
+/*------------------------------------------------------------------------*/
+} // End of 'namespace CaDiCaL'.
+/*------------------------------------------------------------------------*/
+
+int main (int argc, char ** argv) {
+  return CaDiCaL::mobical.main (argc, argv);
+}
diff --git a/hCaD_V2/src/observer.hpp b/hCaD_V2/src/observer.hpp
new file mode 100644
index 0000000..70d0997
--- /dev/null
+++ b/hCaD_V2/src/observer.hpp
@@ -0,0 +1,33 @@
+#ifndef _observer_hpp_INCLUDED
+#define _observer_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+// Proof observer class used to act on added, derived or deleted clauses.
+
+class Observer {
+
+public:
+
+  Observer () { }
+  virtual ~Observer () { }
+
+  // An online proof 'Checker' needs to know original clauses too while a
+  // proof 'Tracer' will not implement this function.
+  //
+  virtual void add_original_clause (const vector<int> &) { }
+
+  // Notify the observer that a new clause has been derived.
+  //
+  virtual void add_derived_clause (const vector<int> &) { }
+
+  // Notify the observer that a clause is not used anymore.
+  //
+  virtual void delete_clause (const vector<int> &) { }
+
+  virtual void flush () { }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/occs.cpp b/hCaD_V2/src/occs.cpp
new file mode 100644
index 0000000..d796589
--- /dev/null
+++ b/hCaD_V2/src/occs.cpp
@@ -0,0 +1,38 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Occurrence lists.
+
+void Internal::init_occs () {
+  while (otab.size () < 2*vsize)
+    otab.push_back (Occs ());
+  LOG ("initialized occurrence lists");
+}
+
+void Internal::reset_occs () {
+  assert (occurring ());
+  erase_vector (otab);
+  LOG ("reset occurrence lists");
+}
+
+/*------------------------------------------------------------------------*/
+
+// One-sided occurrence counter (each literal has its own counter).
+
+void Internal::init_noccs () {
+  assert (ntab.empty ());
+  while (ntab.size () < 2*vsize)
+    ntab.push_back (0);
+  LOG ("initialized two-sided occurrence counters");
+}
+
+void Internal::reset_noccs () {
+  assert (!max_var || !ntab.empty ());
+  erase_vector (ntab);
+  LOG ("reset two-sided occurrence counters");
+}
+
+}
diff --git a/hCaD_V2/src/occs.hpp b/hCaD_V2/src/occs.hpp
new file mode 100644
index 0000000..5aa3873
--- /dev/null
+++ b/hCaD_V2/src/occs.hpp
@@ -0,0 +1,35 @@
+#ifndef _occs_h_INCLUDED
+#define _occs_h_INCLUDED
+
+#include <vector>
+
+namespace CaDiCaL {
+
+// Full occurrence lists used in a one-watch scheme for all clauses in
+// subsumption checking and for irredundant clauses in variable elimination.
+
+struct Clause;
+using namespace std;
+
+typedef vector<Clause*> Occs;
+
+inline void shrink_occs (Occs & os) { shrink_vector (os); }
+inline void erase_occs (Occs & os) { erase_vector (os); }
+
+inline void remove_occs (Occs & os, Clause * c) {
+  const auto end = os.end ();
+  auto i = os.begin ();
+  for (auto j = i; j != end; j++) {
+    const Clause * d = *i++ = *j;
+    if (c == d) i--;
+  }
+  assert (i + 1 == end);
+  os.resize (i - os.begin ());
+}
+
+typedef Occs::iterator occs_iterator;
+typedef Occs::const_iterator const_occs_iterator;
+
+}
+
+#endif
diff --git a/hCaD_V2/src/options.cpp b/hCaD_V2/src/options.cpp
new file mode 100644
index 0000000..519f56a
--- /dev/null
+++ b/hCaD_V2/src/options.cpp
@@ -0,0 +1,336 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// By default, e.g., for library usage, the 'opts.report' value is zero
+// ('false') but can be set to '1' by the stand alone solver.  Using here
+// a static default value avoids that the stand alone solver reports that
+// '--report=1' is different from the default in 'print ()' below.
+//
+int Options::reportdefault;
+
+/*------------------------------------------------------------------------*/
+
+// The order of initializations of static objects is undefined and thus we
+// can not assume that this table is already initialized if a solver and
+// thus the constructor of 'Options' is called.  Therefore we just have to
+// reinitialize this table in every call to 'Options::Options'.  This does
+// not produce a data race even for parallel initialization since the
+// same values are written by all threads under the assumption that the
+// 'reportdefault' is set before any solver is initialized.  We do have to
+// perform this static initialization though, since 'has' is static and does
+// not require that the 'Options' constructor was called.
+
+Option Options::table [] = {
+#define OPTION(N,V,L,H,O,P,R,D) \
+  { #N, (int) V, (int) L, (int) H, (int) O, (bool) P, D },
+  OPTIONS
+#undef OPTION
+};
+
+/*------------------------------------------------------------------------*/
+
+// Binary search in 'table', which requires option names to be sorted, which
+// in turned is checked at start-up in 'Options::Options'.
+
+Option * Options::has (const char * name) {
+  size_t l = 0, r = number_of_options;
+  while (l < r) {
+    size_t m = l + (r - l)/2;
+    Option * res = &table[m];
+    int tmp = strcmp (name, res->name);
+    if (!tmp) return res;
+    if (tmp < 0) r = m;
+    if (tmp > 0) l = m + 1;
+  }
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Options::parse_long_option (const char * arg,
+                                 string & name, int & val) {
+  if (arg[0] != '-' || arg[1] != '-') return false;
+  const bool has_no_prefix =
+    (arg[2] == 'n' && arg[3] == 'o' && arg[4] == '-');
+  const size_t offset = has_no_prefix ? 5 : 2;
+  name = arg + offset;
+  const size_t pos = name.find_first_of ('=');
+  if (pos != string::npos) name[pos] = 0;
+  if (!Options::has (name.c_str ())) return false;
+  if (pos == string::npos) val = !has_no_prefix;
+  else {
+    const char * val_str = name.c_str () + pos + 1;
+    if (!parse_int_str (val_str, val)) return false;
+  }
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::initialize_from_environment (
+  int & val, const char * name, const int L, const int H)
+{
+  char key[80], * q;
+  const char * p;
+  assert (strlen (name) + strlen ("CADICAL_") + 1 < sizeof (key));
+  for (p = "CADICAL_", q = key; *p; p++)
+    *q++ = *p;
+  for (p = name; *p; p++)
+    *q++ = toupper (*p);
+  assert (q < key + sizeof (key));
+  *q = 0;
+  const char * val_str = getenv (key);
+  if (!val_str) return;
+  if (!parse_int_str (val_str, val)) return;
+  if (val < L) val = L;
+  if (val > H) val = H;
+}
+
+// Initialize all the options to their default value 'V'.
+
+Options::Options (Internal * s) : internal (s)
+{
+  assert (number_of_options == sizeof Options::table / sizeof (Option));
+
+  // First initialize them according to defaults in 'options.hpp'.
+  //
+  const char * prev = "";
+  size_t i = 0;
+# define OPTION(N,V,L,H,O,P,R,D) \
+  do { \
+    if ((L) > (V)) \
+      FATAL ("'" #N "' default '" #V "' " \
+        "lower minimum '" #L "' in 'options.hpp'"); \
+    if ((H) < (V)) \
+      FATAL ("'" #N "' default '" #V "' " \
+        "larger maximum '" #H "' in 'options.hpp'"); \
+    if (strcmp (prev, #N) > 0)  \
+      FATAL ("'%s' ordered before '" #N "' in 'options.hpp'", prev); \
+    N = (int)(V); \
+    assert (&val (i) == &N); \
+    /* The order of initializing static data is undefined and thus */ \
+    /* it might be the case that the 'table' is not initialized yet. */ \
+    /* Thus this construction just reinitializes the table too even */ \
+    /* though it might not be necessary. */ \
+    assert (!table[i].name || !strcmp (table[i].name, #N)); \
+    table[i] = { #N, (int)(V), (int)(L), (int)(H), (int)(O), (bool)(P), D }; \
+    prev = #N; \
+    i++; \
+  } while (0);
+  OPTIONS
+# undef OPTION
+
+  // Check consistency in debugging mode.
+  //
+#ifndef NDEBUG
+  assert (i == number_of_options);
+  assert (!has ("aaaaa"));
+  assert (!has ("non-existing-option"));
+  assert (!has ("zzzzz"));
+#endif
+
+  // Now overwrite default options with environment values.
+  //
+# define OPTION(N,V,L,H,O,P,R,D) \
+  initialize_from_environment (N, #N, L, H);
+  OPTIONS
+# undef OPTION
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::set (Option * o, int new_val) {
+  assert (o);
+  int & val = o->val (this), old_val = val;
+  if (old_val == new_val) {
+    LOG ("keeping value '%d' of option '%s'", old_val, o->name);
+    return;
+  }
+  if (new_val < o->lo) {
+    LOG ("bounding '%d' to lower limit '%d' for option '%s'",
+      new_val, o->lo, o->name);
+    new_val = o->lo;
+  }
+  if (new_val > o->hi) {
+    LOG ("bounding '%d' to upper limit '%d' for option '%s'",
+      new_val, o->hi, o->name);
+    new_val = o->hi;
+  }
+  val = new_val;
+  LOG ("set option 'set (\"%s\", %d)' from '%d'",
+    o->name, new_val, old_val);
+}
+
+// Explicit option value setting.
+
+bool Options::set (const char * name, int val) {
+  Option * o = has (name);
+  if (!o) return false;
+  set (o, val);
+  return true;
+}
+
+int Options::get (const char * name) {
+  Option * o = has (name);
+  return o ? o->val (this) : 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::print () {
+  unsigned different = 0;
+#ifdef QUIET
+  const bool verbose = false;
+#endif
+  char buffer[160];
+  // We prefer the macro iteration here since '[VLH]' might be '1e9' etc.
+#define OPTION(N,V,L,H,O,P,R,D) \
+  if (N != (V)) different++; \
+  if (verbose || N != (V)) { \
+    if ((L) == 0 && (H) == 1) { \
+      sprintf (buffer, "--" #N "=%s", (N ? "true" : "false")); \
+      MSG ("  %s%-30s%s (%s default %s'%s'%s)", \
+        ((N == (V)) ? "" : tout.bright_yellow_code ()), \
+        buffer, \
+        ((N == (V)) ? "" : tout.normal_code ()), \
+        ((N == (V)) ? "same as" : "different from"), \
+        ((N == (V)) ? tout.green_code () : tout.yellow_code ()), \
+        (bool)(V) ? "true" : "false", \
+        tout.normal_code ()); \
+    } else { \
+      sprintf (buffer, "--" #N "=%d", N); \
+      MSG ("  %s%-30s%s (%s default %s'" #V "'%s)", \
+        ((N == (V)) ? "" : tout.bright_yellow_code ()), \
+        buffer, \
+        ((N == (V)) ? "" : tout.normal_code ()), \
+        ((N == (V)) ? "same as" : "different from"), \
+        ((N == (V)) ? tout.green_code () : tout.yellow_code ()), \
+        tout.normal_code ()); \
+    } \
+  }
+  OPTIONS
+#undef OPTION
+  if (!different) MSG ("all options are set to their default value");
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::usage () {
+  // We prefer the macro iteration here since '[VLH]' might be '1e9' etc.
+#define OPTION(N,V,L,H,O,P,R,D) \
+  if ((L) == 0 && (H) == 1) \
+    printf ("  %-26s " D " [%s]\n", \
+      "--" #N "=bool", (bool)(V) ? "true" : "false"); \
+  else \
+    printf ("  %-26s " D " [" #V "]\n", \
+      "--" #N "=" #L ".." #H);
+  OPTIONS
+#undef OPTION
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::optimize (int val) {
+
+  if (val < 0) {
+    LOG ("ignoring negative optimization mode '%d'", val);
+    return;
+  }
+
+  const int max_val = 31;
+  if (val > max_val) {
+    LOG ("optimization argument '%d' reduced to '%d'", val, max_val);
+    val = max_val;
+  }
+
+  int64_t factor2 = 1;
+  for (int i = 0; i < val && factor2 <= INT_MAX; i++)
+    factor2 *= 2;
+
+  int64_t factor10 = 1;
+  for (int i = 0; i < val && factor10 <= INT_MAX; i++)
+    factor10 *= 10;
+
+  unsigned increased = 0;
+#define OPTION(N,V,L,H,O,P,R,D) \
+  do { \
+    if (!(O)) break; \
+    const int64_t factor = ((O) == 1 ? factor2 : factor10); \
+    int64_t new_val = factor * (int64_t) (V); \
+    if (new_val > (H)) new_val = (H); \
+    if (new_val == (int) (V)) break; \
+    LOG ("optimization mode '%d' for '%s' " \
+      "gives '%" PRId64 "' instead of '%d", \
+      val, #N, new_val, (int) (V)); \
+    assert (new_val <= INT_MAX); \
+    N = (int) new_val; \
+    increased++; \
+  } while (0);
+  OPTIONS
+#undef OPTION
+  if (increased)
+    MSG ("optimization mode '-O%d' increased %u limits", val, increased);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::disable_preprocessing () {
+  size_t count = 0;
+#define OPTION(N,V,L,H,O,P,R,D) \
+  do { \
+    if (!(P)) break; \
+    if (!(N)) break; \
+    assert ((L) == 0); \
+    assert ((H) == 1); \
+    LOG ("plain mode disables '%s'", #N); \
+    count++; \
+    N = 0; \
+  } while (0);
+  OPTIONS
+#undef OPTION
+  LOG ("forced plain mode disabled %zd preprocessing options", count);
+}
+
+bool Options::is_preprocessing_option (const char * name) {
+  Option * o = has (name);
+  return o ? o->preprocessing : false;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::reset_default_values () {
+  size_t count = 0;
+#define OPTION(N,V,L,H,O,P,R,D) \
+  do { \
+    if (!(R)) break; \
+    if (N == (V)) break; \
+    LOG ("resetting option '%s' to default %s", #N, #V); \
+    count++; \
+    N = (int)(V); \
+  } while (0);
+  OPTIONS
+#undef OPTION
+  LOG ("reset %zd options to their default values", count);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::copy (Options & other) const {
+#ifdef LOGGING
+  Internal * internal = other.internal;
+#endif
+#define OPTION(N,V,L,H,O,P,R,D) \
+  if ((N) == (int)(V)) \
+    LOG ("keeping non default option '--%s=%s'", #N, #V); \
+  else if ((N) != (int)(V)) { \
+    LOG ("overwriting default option by '--%s=%d'", #N, N); \
+    other.N = N; \
+  }
+  OPTIONS
+#undef OPTION
+}
+
+}
diff --git a/hCaD_V2/src/options.hpp b/hCaD_V2/src/options.hpp
new file mode 100644
index 0000000..3cc1251
--- /dev/null
+++ b/hCaD_V2/src/options.hpp
@@ -0,0 +1,347 @@
+#ifndef _options_hpp_INCLUDED
+#define _options_hpp_INCLUDED
+
+/*------------------------------------------------------------------------*/
+
+// In order to add a new option, simply add a new line below. Make sure that
+// options are sorted correctly (with '!}sort -k 2' in 'vi').  Otherwise
+// initializing the options will trigger an internal error.  For the model
+// based tester 'mobical' the policy is that options which become redundant
+// because another one is disabled (set to zero) should have the name of the
+// latter as prefix.  The 'O' column determines the options which are
+// target to 'optimize' them ('-O[1-3]').  A zero value in the 'O' column
+// means that this option is not optimized.  A value of '1' results in
+// optimizing its value exponentially with exponent base '2', and a value
+// of '2' uses base '10'.  The 'P' column determines simplification
+// options (disabled with '--plain') and 'R' which values can be reset.
+
+#define OPTIONS \
+\
+/*      NAME         DEFAULT, LO, HI,O,P,R, USAGE */ \
+\
+OPTION( arena,             1,  0,  1,0,0,1, "allocate clauses in arena") \
+OPTION( arenacompact,      1,  0,  1,0,0,1, "keep clauses compact") \
+OPTION( arenasort,         1,  0,  1,0,0,1, "sort clauses in arena") \
+OPTION( arenatype,         3,  1,  3,0,0,1, "1=clause, 2=var, 3=queue") \
+OPTION( binary,            1,  0,  1,0,0,1, "use binary proof format") \
+OPTION( block,             0,  0,  1,0,1,1, "blocked clause elimination") \
+OPTION( blockmaxclslim,  1e5,  1,2e9,2,0,1, "maximum clause size") \
+OPTION( blockminclslim,    2,  2,2e9,0,0,1, "minimum clause size") \
+OPTION( blockocclim,     1e2,  1,2e9,2,0,1, "occurrence limit") \
+OPTION( bump,              1,  0,  1,0,0,1, "bump variables") \
+OPTION( bumpreason,        1,  0,  1,0,0,1, "bump reason literals too") \
+OPTION( bumpreasondepth,   1,  1,  3,0,0,1, "bump reason depth") \
+OPTION( check,             0,  0,  1,0,0,0, "enable internal checking") \
+OPTION( checkassumptions,  1,  0,  1,0,0,0, "check assumptions satisfied") \
+OPTION( checkfailed,       1,  0,  1,0,0,0, "check failed literals form core") \
+OPTION( checkfrozen,       0,  0,  1,0,0,0, "check all frozen semantics") \
+OPTION( checkproof,        1,  0,  1,0,0,0, "check proof internally") \
+OPTION( checkwitness,      1,  0,  1,0,0,0, "check witness internally") \
+OPTION( chrono,            0,  0,  2,0,0,1, "chronological backtracking") \
+OPTION( chronoalways,      0,  0,  1,0,0,1, "force always chronological") \
+OPTION( chronolevelim,   1e2,  0,2e9,0,0,1, "chronological level limit") \
+OPTION( chronoreusetrail,  1,  0,  1,0,0,1, "reuse trail chronologically") \
+OPTION( compact,           1,  0,  1,0,1,1, "compact internal variables") \
+OPTION( compactint,      2e3,  1,2e9,0,0,1, "compacting interval") \
+OPTION( compactlim,      1e2,  0,1e3,0,0,1, "inactive limit per mille") \
+OPTION( compactmin,      1e2,  1,2e9,0,0,1, "minimum inactive limit") \
+OPTION( condition,         0,  0,  1,0,0,1, "globally blocked clause elim") \
+OPTION( conditionint,    1e4,  1,2e9,0,0,1, "initial conflict interval") \
+OPTION( conditionmaxeff, 1e7,  0,2e9,1,0,1, "maximum condition efficiency") \
+OPTION( conditionmaxrat, 100,  1,2e9,1,0,1, "maximum clause variable ratio") \
+OPTION( conditionmineff, 1e6,  0,2e9,1,0,1, "minimum condition efficiency") \
+OPTION( conditionreleff, 100,  1,1e5,0,0,1, "relative efficiency per mille") \
+OPTION( cover,             0,  0,  1,0,1,1, "covered clause elimination") \
+OPTION( covermaxclslim,  1e5,  1,2e9,2,0,1, "maximum clause size") \
+OPTION( covermaxeff,     1e8,  0,2e9,1,0,1, "maximum cover efficiency") \
+OPTION( coverminclslim,    2,  2,2e9,0,0,1, "minimum clause size") \
+OPTION( covermineff,     1e6,  0,2e9,1,0,1, "minimum cover efficiency") \
+OPTION( coverreleff,       4,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( decompose,         1,  0,  1,0,1,1, "decompose BIG in SCCs and ELS") \
+OPTION( decomposerounds,   2,  1, 16,1,0,1, "number of decompose rounds") \
+OPTION( deduplicate,       1,  0,  1,0,1,1, "remove duplicated binaries") \
+OPTION( eagersubsume,      1,  0,  1,0,0,1, "subsume recently learned") \
+OPTION( eagersubsumelim,  20,  1,1e3,0,0,1, "limit on subsumed candidates") \
+OPTION( elim,              1,  0,  1,0,1,1, "bounded variable elimination") \
+OPTION( elimands,          1,  0,  1,0,0,1, "find AND gates") \
+OPTION( elimaxeff,       2e9,  0,2e9,1,0,1, "maximum elimination efficiency") \
+OPTION( elimbackward,      1,  0,  1,0,0,1, "eager backward subsumption") \
+OPTION( elimboundmax,     16, -1,2e6,1,0,1, "maximum elimination bound") \
+OPTION( elimboundmin,      0, -1,2e6,0,0,1, "minimum elimination bound") \
+OPTION( elimclslim,      1e2,  2,2e9,2,0,1, "resolvent size limit") \
+OPTION( elimequivs,        1,  0,  1,0,0,1, "find equivalence gates") \
+OPTION( elimineff,       1e7,  0,2e9,1,0,1, "minimum elimination efficiency") \
+OPTION( elimint,         2e3,  1,2e9,0,0,1, "elimination interval") \
+OPTION( elimites,          1,  0,  1,0,0,1, "find if-then-else gates") \
+OPTION( elimlimited,       1,  0,  1,0,0,1, "limit resolutions") \
+OPTION( elimocclim,      1e2,  0,2e9,2,0,1, "occurrence limit") \
+OPTION( elimprod,          1,  0,1e4,0,0,1, "elim score product weight") \
+OPTION( elimreleff,      1e3,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( elimrounds,        2,  1,512,1,0,1, "usual number of rounds") \
+OPTION( elimsubst,         1,  0,  1,0,0,1, "elimination by substitution") \
+OPTION( elimsum,           1,  0,1e4,0,0,1, "elimination score sum weight") \
+OPTION( elimxorlim,        5,  2, 27,1,0,1, "maximum XOR size") \
+OPTION( elimxors,          1,  0,  1,0,0,1, "find XOR gates") \
+OPTION( emagluefast,      33,  1,2e9,0,0,1, "window fast glue") \
+OPTION( emaglueslow,     1e5,  1,2e9,0,0,1, "window slow glue") \
+OPTION( emajump,         1e5,  1,2e9,0,0,1, "window back-jump level") \
+OPTION( emalevel,        1e5,  1,2e9,0,0,1, "window back-track level") \
+OPTION( emasize,         1e5,  1,2e9,0,0,1, "window learned clause size") \
+OPTION( ematrailfast,    1e2,  1,2e9,0,0,1, "window fast trail") \
+OPTION( ematrailslow,    1e5,  1,2e9,0,0,1, "window slow trail") \
+OPTION( flush,             0,  0,  1,0,0,1, "flush redundant clauses") \
+OPTION( flushfactor,       3,  1,1e3,0,0,1, "interval increase") \
+OPTION( flushint,        1e5,  1,2e9,0,0,1, "initial limit") \
+OPTION( forcephase,        0,  0,  1,0,0,1, "always use initial phase") \
+OPTION( inprocessing,      1,  0,  1,0,0,1, "enable inprocessing") \
+OPTION( instantiate,       0,  0,  1,0,1,1, "variable instantiation") \
+OPTION( instantiateclslim, 3,  2,2e9,0,0,1, "minimum clause size") \
+OPTION( instantiateocclim, 1,  1,2e9,2,0,1, "maximum occurrence limit") \
+OPTION( instantiateonce,   1,  0,  1,0,0,1, "instantiate each clause once") \
+LOGOPT( log,               0,  0,  1,0,0,0, "enable logging") \
+LOGOPT( logsort,           0,  0,  1,0,0,0, "sort logged clauses") \
+OPTION( lucky,             1,  0,  1,0,0,1, "search for lucky phases") \
+OPTION( minimize,          1,  0,  1,0,0,1, "minimize learned clauses") \
+OPTION( minimizedepth,   1e3,  0,1e3,0,0,1, "minimization depth") \
+OPTION( phase,             1,  0,  1,0,0,1, "initial phase") \
+OPTION( probe,             1,  0,  1,0,1,1, "failed literal probing" ) \
+OPTION( probehbr,          1,  0,  1,0,0,1, "learn hyper binary clauses") \
+OPTION( probeint,        5e3,  1,2e9,0,0,1, "probing interval" ) \
+OPTION( probemaxeff,     1e8,  0,2e9,1,0,1, "maximum probing efficiency") \
+OPTION( probemineff,     1e6,  0,2e9,1,0,1, "minimum probing efficiency") \
+OPTION( probereleff,      20,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( proberounds,       1,  1, 16,1,0,1, "probing rounds" ) \
+OPTION( profile,           2,  0,  4,0,0,0, "profiling level") \
+OPTION( psids,             0,  0,  1,0,0,1, "use PSIDS heuristic for polarity") \
+QUTOPT( quiet,             0,  0,  1,0,0,0, "disable all messages") \
+OPTION( radixsortlim,    800,  0,2e9,0,0,1, "radix sort limit") \
+OPTION( realtime,          0,  0,  1,0,0,0, "real instead of process time") \
+OPTION( reduce,            1,  0,  1,0,0,1, "reduce useless clauses") \
+OPTION( reduceint,       300, 10,1e6,0,0,1, "reduce interval") \
+OPTION( reducetarget,     75, 10,1e2,0,0,1, "reduce fraction in percent") \
+OPTION( reducetier1glue,   2,  1,2e9,0,0,1, "glue of kept learned clauses") \
+OPTION( reducetier2glue,   6,  1,2e9,0,0,1, "glue of tier two clauses") \
+OPTION( reluctant,      1024,  0,2e9,0,0,1, "reluctant doubling period") \
+OPTION( reluctantmax,1048576,  0,2e9,0,0,1, "reluctant doubling period") \
+OPTION( rephase,           1,  0,  1,0,0,1, "enable resetting phase") \
+OPTION( rephaseint,      1e3,  1,2e9,0,0,1, "rephase interval") \
+OPTION( report,reportdefault,  0,  1,0,0,1, "enable reporting") \
+OPTION( reportall,         0,  0,  1,0,0,1, "report even if not successful") \
+OPTION( reportsolve,       0,  0,  1,0,0,1, "use solving not process time") \
+OPTION( restart,           1,  0,  1,0,0,1, "enable restarts") \
+OPTION( restartint,        2,  1,2e9,0,0,1, "restart interval") \
+OPTION( restartmargin,    10,  0,1e2,0,0,1, "slow fast margin in percent") \
+OPTION( restartreusetrail, 1,  0,  1,0,0,1, "enable trail reuse") \
+OPTION( restoreall,        0,  0,  2,0,0,1, "restore all clauses (2=really)") \
+OPTION( restoreflush,      0,  0,  1,0,0,1, "remove satisfied clauses") \
+OPTION( reverse,           0,  0,  1,0,0,1, "reverse variable ordering") \
+OPTION( score,             1,  0,  1,0,0,1, "use EVSIDS scores") \
+OPTION( scorefactor,     950,500,1e3,0,0,1, "score factor per mille") \
+OPTION( seed,              0,  0,2e9,0,0,1, "random seed") \
+OPTION( shrink,            3,  0,  3,0,0,1, "shrink conflict clause") \
+OPTION( shrinkreap,        1,  0,  1,0,0,1, "use a reap for shrinking") \
+OPTION( shuffle,           0,  0,  1,0,0,1, "shuffle variables") \
+OPTION( shufflequeue,      1,  0,  1,0,0,1, "shuffle variable queue") \
+OPTION( shufflerandom,     0,  0,  1,0,0,1, "not reverse but random") \
+OPTION( shufflescores,     1,  0,  1,0,0,1, "shuffle variable scores") \
+OPTION( stabilize,         1,  0,  1,0,0,1, "enable stabilizing phases") \
+OPTION( stabilizefactor, 200,101,2e9,0,0,1, "phase increase in percent") \
+OPTION( stabilizeint,    1e3,  1,2e9,0,0,1, "stabilizing interval") \
+OPTION( stabilizemaxint, 2e9,  1,2e9,0,0,1, "maximum stabilizing phase") \
+OPTION( stabilizeonly,     0,  0,  1,0,0,1, "only stabilizing phases") \
+OPTION( subsume,           1,  0,  1,0,1,1, "enable clause subsumption") \
+OPTION( subsumebinlim,   1e4,  0,2e9,1,0,1, "watch list length limit") \
+OPTION( subsumeclslim,   1e2,  0,2e9,2,0,1, "clause length limit") \
+OPTION( subsumeint,      1e4,  1,2e9,0,0,1, "subsume interval") \
+OPTION( subsumelimited,    1,  0,  1,0,0,1, "limit subsumption checks") \
+OPTION( subsumemaxeff,   1e8,  0,2e9,1,0,1, "maximum subsuming efficiency") \
+OPTION( subsumemineff,   1e6,  0,2e9,1,0,1, "minimum subsuming efficiency") \
+OPTION( subsumeocclim,   1e2,  0,2e9,1,0,1, "watch list length limit") \
+OPTION( subsumereleff,   1e3,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( subsumestr,        1,  0,  1,0,0,1, "strengthen during subsume") \
+OPTION( target,            2,  0,  2,0,0,1, "target phases (1=stable only)") \
+OPTION( terminateint,     10,  0,1e4,0,0,1, "termination check interval") \
+OPTION( ternary,           1,  0,  1,0,1,1, "hyper ternary resolution") \
+OPTION( ternarymaxadd,   1e3,  0,1e4,1,0,1, "max clauses added in percent") \
+OPTION( ternarymaxeff,   1e8,  0,2e9,1,0,1, "ternary maximum efficiency") \
+OPTION( ternarymineff,   1e6,  1,2e9,1,0,1, "minimum ternary efficiency") \
+OPTION( ternaryocclim,   1e2,  1,2e9,2,0,1, "ternary occurrence limit") \
+OPTION( ternaryreleff,    10,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( ternaryrounds,     2,  1, 16,1,0,1, "maximum ternary rounds") \
+OPTION( transred,          1,  0,  1,0,1,1, "transitive reduction of BIG") \
+OPTION( transredmaxeff,  1e8,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( transredmineff,  1e6,  0,2e9,1,0,1, "minimum efficiency") \
+OPTION( transredreleff,  1e2,  1,1e5,1,0,1, "relative efficiency per mille") \
+QUTOPT( verbose,           0,  0,  3,0,0,0, "more verbose messages") \
+OPTION( vivify,            1,  0,  1,0,1,1, "vivification") \
+OPTION( vivifymaxeff,    2e7,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( vivifymineff,    2e4,  0,2e9,1,0,1, "minimum efficiency") \
+OPTION( vivifyonce,        0,  0,  2,0,0,1, "vivify once: 1=red, 2=red+irr") \
+OPTION( vivifyredeff,     75,  0,1e3,1,0,1, "redundant efficiency per mille") \
+OPTION( vivifyreleff,     20,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( walk,              0,  0,  1,0,0,1, "enable random walks") \
+OPTION( walkmaxeff,      1e7,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( walkmineff,      1e5,  0,1e7,1,0,1, "minimum efficiency") \
+OPTION( walknonstable,     1,  0,  1,0,0,1, "walk in non-stabilizing phase") \
+OPTION( walkredundant,     0,  0,  1,0,0,1, "walk redundant clauses too") \
+OPTION( walkreleff,       20,  1,1e5,1,0,1, "relative efficiency per mille") \
+
+// Note, keep an empty line right before this line because of the last '\'!
+// Also keep those single spaces after 'OPTION(' for proper sorting.
+
+/*------------------------------------------------------------------------*/
+
+// Some of the 'OPTION' macros above should only be included if certain
+// compile time options are enabled.  This has the effect, that for instance
+// if 'LOGGING' is defined, and thus logging code is included, then also the
+// 'log' option is defined.  Otherwise the 'log' option is not included.
+
+#ifdef LOGGING
+#define LOGOPT OPTION
+#else
+#define LOGOPT(...) /**/
+#endif
+
+#ifdef QUIET
+#define QUTOPT(...) /**/
+#else
+#define QUTOPT OPTION
+#endif
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+struct Internal;
+
+/*------------------------------------------------------------------------*/
+
+class Options;
+
+struct Option {
+  const char * name;
+  int def, lo, hi;
+  int optimizable;
+  bool preprocessing;
+  const char * description;
+  int & val (Options *);
+};
+
+/*------------------------------------------------------------------------*/
+
+// Produce a compile time constant for the number of options.
+
+static const size_t number_of_options =
+#define OPTION(N,V,L,H,O,P,R,D) 1 +
+OPTIONS
+#undef OPTION
++ 0;
+
+/*------------------------------------------------------------------------*/
+
+class Options {
+
+  Internal * internal;
+
+  void set (Option *, int val); // Force to [lo,hi] interval.
+
+  friend struct Option;
+  static Option table[];
+
+  static void initialize_from_environment (
+    int & val, const char * name, const int L, const int H);
+
+  friend Config;
+
+  void reset_default_values ();
+  void disable_preprocessing ();
+
+public:
+
+  // For library usage we disable reporting by default while for the stand
+  // alone SAT solver we enable it by default.  This default value has to
+  // be set before the constructor of 'Options' is called (which in turn is
+  // called from the constructor of 'Solver').  If we would simply overwrite
+  // its initial value while initializing the stand alone solver,  we will
+  // get that change of the default value (from 'false' to 'true') shown
+  // during calls to 'print ()', which is confusing to the user.
+  //
+  static int reportdefault;
+
+  Options (Internal *);
+
+  // Makes options directly accessible, e.g., for instance declares the
+  // member 'int restart' here.  This will give fast access to option values
+  // internally in the solver and thus can also be used in tight loops.
+  //
+private:
+  int __start_of_options__;             // Used by 'val' below.
+public:
+# define OPTION(N,V,L,H,O,P,R,D) \
+  int N;                                // Access option values by name.
+  OPTIONS
+# undef OPTION
+
+  // It would be more elegant to use an anonymous 'struct' of the actual
+  // option values overlayed with an 'int values[number_of_options]' array
+  // but that is not proper ISO C++ and produces a warning.  Instead we use
+  // the following construction which relies on '__start_of_options__' and
+  // that the following options are really allocated directly after it.
+  //
+  inline int & val (size_t idx) {
+    assert (idx < number_of_options);
+    return (&__start_of_options__ + 1)[idx];
+  }
+
+  // With the following function we can get rather fast access to the option
+  // limits, the default value and the description.  The code uses binary
+  // search over the sorted option 'table'.  This static data is shared
+  // among different instances of the solver.  The actual current option
+  // values are here in the 'Options' class.  They can be accessed by the
+  // offset of the static options using 'Option::val' if you have an
+  // 'Option' or to have even faster access directly by the member function
+  // (the 'N' above, e.g., 'restart').
+  //
+  static Option * has (const char * name);
+
+  bool set (const char * name, int);    // Explicit version.
+  int  get (const char * name);         // Get current value.
+
+  void print ();             // Print current values in command line form
+  static void usage ();      // Print usage message for all options.
+
+  void optimize (int val);   // increase some limits (val=0..31)
+
+  static bool is_preprocessing_option (const char * name);
+
+  // Parse long option argument
+  //
+  //   --<name>
+  //   --<name>=<val>
+  //   --no-<name>
+  //
+  // where '<val>' is as in 'parse_option_value'.  If parsing succeeds,
+  // 'true' is returned and the string will be set to the name of the
+  // option.  Additionally the parsed value is set (last argument).
+  //
+  static bool parse_long_option (const char *, string &, int &);
+
+  // Iterating options.
+
+  typedef Option * iterator;
+  typedef const Option * const_iterator;
+
+  static iterator begin () { return table; }
+  static iterator end () { return table + number_of_options; }
+
+  void copy (Options & other) const;    // Copy 'this' into 'other'.
+};
+
+inline int & Option::val (Options * opts) {
+  assert (Options::table <= this && this < Options::table + number_of_options);
+  return opts->val (this - Options::table);
+}
+
+}
+
+#endif
diff --git a/hCaD_V2/src/parse.cpp b/hCaD_V2/src/parse.cpp
new file mode 100644
index 0000000..21bb620
--- /dev/null
+++ b/hCaD_V2/src/parse.cpp
@@ -0,0 +1,368 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Parse error.
+
+#define PER(...) \
+do { \
+  internal->error_message.init ("%s:%" PRIu64 ": parse error: ", \
+    file->name (), (uint64_t) file->lineno ()); \
+  return internal->error_message.append (__VA_ARGS__); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+// Parsing utilities.
+
+inline int Parser::parse_char () { return file->get (); }
+
+// Return an non zero error string if a parse error occurred.
+
+inline const char *
+Parser::parse_string (const char * str, char prev) {
+  for (const char * p = str; *p; p++)
+    if (parse_char () == *p) prev = *p;
+    else if (*p == ' ') PER ("expected space after '%c'", prev);
+    else PER ("expected '%c' after '%c'", *p, prev);
+  return 0;
+}
+
+inline const char *
+Parser::parse_positive_int (int & ch, int & res, const char * name) {
+  assert (isdigit (ch));
+  res = ch - '0';
+  while (isdigit (ch = parse_char ())) {
+    int digit = ch - '0';
+    if (INT_MAX/10 < res || INT_MAX - digit < 10*res)
+      PER ("too large '%s' in header", name);
+    res = 10*res + digit;
+  }
+  return 0;
+}
+
+static const char * cube_token = "unexpected 'a' in CNF";
+
+inline const char *
+Parser::parse_lit (int & ch, int & lit, int & vars, int strict) {
+  if (ch == 'a')
+    return cube_token;
+  int sign = 0;
+  if (ch == '-') {
+    if (!isdigit (ch = parse_char ())) PER ("expected digit after '-'");
+    sign = -1;
+  } else if (!isdigit (ch)) PER ("expected digit or '-'");
+  else sign = 1;
+  lit = ch - '0';
+  while (isdigit (ch = parse_char ())) {
+    int digit = ch - '0';
+    if (INT_MAX/10 < lit || INT_MAX - digit < 10*lit)
+      PER ("literal too large");
+    lit = 10*lit + digit;
+  }
+  if (ch == '\r') ch = parse_char ();
+  if (ch != 'c' && ch != ' ' && ch != '\t' && ch != '\n' && ch != EOF)
+    PER ("expected white space after '%d'", sign*lit);
+  if (lit > vars) {
+    if (strict != FORCED)
+      PER ("literal %d exceeds maximum variable %d", sign*lit, vars);
+    else vars = lit;
+  }
+  lit *= sign;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Parsing CNF in DIMACS format.
+
+const char * Parser::parse_dimacs_non_profiled (int & vars, int strict) {
+
+#ifndef QUIET
+  double start = internal->time ();
+#endif
+
+  bool found_inccnf_header = false;
+  int ch, clauses = 0;
+  vars = 0;
+
+  // First read comments before header with possibly embedded options.
+  //
+  for (;;) {
+    ch = parse_char ();
+    if (strict != STRICT)
+      if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') continue;
+    if (ch != 'c') break;
+    string buf;
+    while ((ch = parse_char ()) != '\n')
+      if (ch == EOF) PER ("unexpected end-of-file in header comment");
+      else if (ch != '\r') buf.push_back (ch);
+    const char * o;
+    for (o = buf.c_str (); *o && *o != '-'; o++)
+      ;
+    if (!*o) continue;
+    PHASE ("parse-dimacs", "found option '%s'", o);
+    if (*o) solver->set_long_option (o);
+  }
+
+  if (ch != 'p') PER ("expected 'c' or 'p'");
+
+  ch = parse_char ();
+  if (strict == STRICT) {
+    if (ch != ' ') PER ("expected space after 'p'");
+    ch = parse_char ();
+  } else if (ch != ' ' && ch != '\t')
+    PER ("expected white space after 'p'");
+  else {
+    do ch = parse_char (); while (ch == ' ' || ch == '\t');
+  }
+
+  // Now read 'p cnf <var> <clauses>' header of DIMACS file
+  // or 'p inccnf' of incremental 'INCCNF' file.
+  //
+  if (ch == 'c')
+    {
+      assert (!found_inccnf_header);
+      if (strict == STRICT) {
+        const char * err = parse_string ("nf ", 'c');
+        if (err) return err;
+        ch = parse_char ();
+        if (!isdigit (ch)) PER ("expected digit after 'p cnf '");
+        err = parse_positive_int (ch, vars, "<max-var>");
+        if (err) return err;
+        if (ch != ' ') PER ("expected ' ' after 'p cnf %d'", vars);
+        if (!isdigit (ch = parse_char ()))
+          PER ("expected digit after 'p cnf %d '", vars);
+        err = parse_positive_int (ch, clauses, "<num-clauses>");
+        if (err) return err;
+        if (ch != '\n')
+          PER ("expected new-line after 'p cnf %d %d'", vars, clauses);
+      } else {
+        if (parse_char () != 'n') PER ("expected 'n' after 'p c'");
+        if (parse_char () != 'f') PER ("expected 'f' after 'p cn'");
+        ch = parse_char ();
+        if (!isspace (ch)) PER ("expected space after 'p cnf'");
+        do ch = parse_char (); while (isspace (ch));
+        if (!isdigit (ch)) PER ("expected digit after 'p cnf '");
+        const char * err = parse_positive_int (ch, vars, "<max-var>");
+        if (err) return err;
+        if (!isspace (ch)) PER ("expected space after 'p cnf %d'", vars);
+        do ch = parse_char (); while (isspace (ch));
+        if (!isdigit (ch)) PER ("expected digit after 'p cnf %d '", vars);
+        err = parse_positive_int (ch, clauses, "<num-clauses>");
+        if (err) return err;
+        while (ch != '\n') {
+          if (ch != '\r' && !isspace (ch))
+            PER ("expected new-line after 'p cnf %d %d'", vars, clauses);
+          ch = parse_char ();
+        }
+      }
+
+      MSG ("found %s'p cnf %d %d'%s header",
+        tout.green_code (), vars, clauses, tout.normal_code ());
+
+      if (strict != FORCED)
+        solver->reserve (vars);
+    }
+  else if (!parse_inccnf_too)
+    PER ("expected 'c' after 'p '");
+  else if (ch == 'i')
+    {
+      found_inccnf_header = true;
+      const char * err = parse_string ("nccnf", 'i');
+      if (err) return err;
+      ch = parse_char ();
+      if (strict == STRICT) {
+        if (ch != '\n')
+          PER ("expected new-line after 'p inccnf'");
+      } else {
+        while (ch != '\n')
+          {
+            if (ch != '\r' && !isspace (ch))
+              PER ("expected new-line after 'p inccnf'");
+            ch = parse_char ();
+          }
+      }
+
+      MSG ("found %s'p inccnf'%s header",
+        tout.green_code (), tout.normal_code ());
+
+      strict = FORCED;
+    }
+  else
+    PER ("expected 'c' or 'i' after 'p '");
+
+  if (parse_inccnf_too)
+    *parse_inccnf_too = false;
+
+  // Now read body of DIMACS part.
+  //
+  int lit = 0, parsed = 0;
+  while ((ch = parse_char ()) != EOF) {
+    if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') continue;
+    if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n' && ch != EOF)
+        ;
+      if (ch == EOF) break;
+      continue;
+    }
+    if (ch == 'a' && found_inccnf_header) break;
+    const char * err = parse_lit (ch, lit, vars, strict);
+    if (err) return err;
+    if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n')
+        if (ch == EOF)
+          PER ("unexpected end-of-file in comment");
+    }
+    solver->add (lit);
+    if (!found_inccnf_header &&
+        !lit && parsed++ >= clauses && strict != FORCED)
+      PER ("too many clauses");
+  }
+
+  if (lit) PER ("last clause without terminating '0'");
+
+  if (!found_inccnf_header && parsed < clauses && strict != FORCED)
+    PER ("clause missing");
+
+#ifndef QUIET
+  double end = internal->time ();
+  MSG ("parsed %d clauses in %.2f seconds %s time",
+    parsed, end - start, internal->opts.realtime ? "real" : "process");
+#endif
+
+#ifndef QUIET
+  start = end;
+#endif
+  size_t num_cubes = 0;
+  if (ch == 'a') {
+    assert (parse_inccnf_too);
+    assert (found_inccnf_header);
+    if (!*parse_inccnf_too) *parse_inccnf_too = true;
+    for (;;) {
+      ch = parse_char ();
+      if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+        continue;
+      if (ch == 'c') {
+        while ((ch = parse_char ()) != '\n' && ch != EOF)
+          ;
+        if (ch == EOF) break;
+        continue;
+      }
+      const char * err = parse_lit (ch, lit, vars, strict);
+      if (err == cube_token) PER ("two 'a' in a row");
+      else if (err) return err;
+      if (ch == 'c') {
+        while ((ch = parse_char ()) != '\n')
+          if (ch == EOF)
+            PER ("unexpected end-of-file in comment");
+      }
+      if (cubes)
+        cubes->push_back (lit);
+      if (!lit) {
+        num_cubes++;
+        for (;;)
+          {
+            ch = parse_char ();
+            if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+              continue;
+            if (ch == 'c') {
+              while ((ch = parse_char ()) != '\n' && ch != EOF)
+                ;
+              if (ch == EOF) break;
+            }
+            if (ch == EOF) break;
+            if (ch != 'a')
+              PER ("expected 'a' or end-of-file after zero");
+            lit = INT_MIN;
+            break;
+          }
+        if (ch == EOF) break;
+      }
+    }
+    if (lit) PER ("last cube without terminating '0'");
+  }
+#ifndef QUIET
+  if (found_inccnf_header)
+    {
+      double end = internal->time ();
+      MSG ("parsed %zd cubes in %.2f seconds %s time",
+        num_cubes, end - start, internal->opts.realtime ? "real" : "process");
+    }
+#endif
+
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Parsing solution in competition output format.
+
+const char * Parser::parse_solution_non_profiled () {
+  external->solution = new signed char [ external->max_var + 1u ];
+  clear_n (external->solution, external->max_var + 1u);
+  int ch;
+  for (;;) {
+    ch = parse_char ();
+    if (ch == EOF) PER ("missing 's' line");
+    else if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n')
+        if (ch == EOF) PER ("unexpected end-of-file in comment");
+    } else if (ch == 's') break;
+    else PER ("expected 'c' or 's'");
+  }
+  const char * err = parse_string (" SATISFIABLE", 's');
+  if (err) return err;
+  if ((ch = parse_char ()) == '\r') ch = parse_char ();
+  if (ch != '\n') PER ("expected new-line after 's SATISFIABLE'");
+  int count = 0;
+  for (;;) {
+    ch = parse_char ();
+    if (ch != 'v') PER ("expected 'v' at start-of-line");
+    if ((ch = parse_char ()) != ' ') PER ("expected ' ' after 'v'");
+    int lit = 0; ch = parse_char ();
+    do {
+      if (ch == ' ' || ch == '\t') { ch = parse_char (); continue; }
+      err = parse_lit (ch, lit, external->max_var, false);
+      if (err) return err;
+      if (ch == 'c') PER ("unexpected comment");
+      if (!lit) break;
+      if (external->solution[abs (lit)])
+        PER ("variable %d occurs twice", abs (lit));
+      LOG ("solution %d", lit);
+      external->solution [abs (lit)] = sign (lit);
+      count++;
+      if (ch == '\r') ch = parse_char ();
+    } while (ch != '\n');
+    if (!lit) break;
+  }
+  MSG ("parsed %d values %.2f%%",
+    count, percent (count, external->max_var));
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Wrappers to profile parsing and at the same time use the convenient
+// implicit 'return' in PER in the non-profiled versions.
+
+const char * Parser::parse_dimacs (int & vars, int strict) {
+  assert (strict == FORCED || strict == RELAXED || strict == STRICT);
+  START (parse);
+  const char * err = parse_dimacs_non_profiled (vars, strict);
+  STOP (parse);
+  return err;
+}
+
+const char * Parser::parse_solution () {
+  START (parse);
+  const char * err = parse_solution_non_profiled ();
+  STOP (parse);
+  return err;
+}
+
+}
diff --git a/hCaD_V2/src/parse.hpp b/hCaD_V2/src/parse.hpp
new file mode 100644
index 0000000..a8a98ab
--- /dev/null
+++ b/hCaD_V2/src/parse.hpp
@@ -0,0 +1,75 @@
+#ifndef _parse_hpp_INCLUDED
+#define _parse_hpp_INCLUDED
+
+#include <cassert>
+#include <vector>
+
+namespace CaDiCaL {
+
+// Factors out common functions for parsing of DIMACS and solution files.
+
+class File;
+struct External;
+struct Internal;
+
+class Parser {
+
+  Solver * solver;
+  Internal * internal;
+  External * external;
+  File * file;
+
+  void perr (const char * fmt, ...)
+             CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  int parse_char ();
+
+  enum {
+    FORCED = 0,         // Force reading even if header is broken.
+    RELAXED = 1,        // Relaxed white space treatment in header.
+    STRICT = 2,         // Strict white space and header compliance.
+  };
+
+  const char * parse_string (const char * str, char prev);
+  const char * parse_positive_int (int & ch, int & res, const char * name);
+  const char * parse_lit (int & ch, int & lit, int & vars, int strict);
+  const char * parse_dimacs_non_profiled (int & vars, int strict);
+  const char * parse_solution_non_profiled ();
+
+  bool * parse_inccnf_too;
+  vector<int> * cubes;
+
+public:
+
+  // Parse a DIMACS CNF or ICNF file.
+  //
+  // Return zero if successful. Otherwise parse error.
+   Parser(Solver *s, File *f, bool *i, vector<int> *c) :
+     solver(s), internal(s->internal), external(s->external), file(f),
+    parse_inccnf_too (i), cubes (c)
+  {}
+
+  // Parse a DIMACS file.  Return zero if successful. Otherwise a parse
+  // error is return. The parsed clauses are added to the solver and the
+  // maximum variable index found is returned in the 'vars' argument. The
+  // 'strict' argument can be '0' in which case the numbers in the header
+  // can be arbitrary, e.g., 'p cnf 0 0' all the time, without producing a
+  // parse error.  Only for this setting the parsed literals are not checked
+  // to overflow the maximum variable index of the header.  The strictest
+  // form of parsing is enforced  for the value '2' of 'strict', in which
+  // case the header can not have additional white space, while a value of
+  // '1' exactly relaxes this, e.g., 'p cnf \t  1   3  \r\n' becomes legal.
+  //
+  const char * parse_dimacs (int & vars, int strict);
+
+  // Parse a solution file as used in the SAT competition, e.g., with
+  // comment lines 'c ...', a status line 's ...' and value lines 'v ...'.
+  // Returns zero if successful. Otherwise a string is returned describing
+  // the parse error.  The parsed solution is saved in 'solution' and can be
+  // accessed with 'sol (int lit)'.  We use it for checking learned clauses.
+  //
+  const char * parse_solution ();
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/phases.cpp b/hCaD_V2/src/phases.cpp
new file mode 100644
index 0000000..dc768db
--- /dev/null
+++ b/hCaD_V2/src/phases.cpp
@@ -0,0 +1,38 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::copy_phases (vector<signed char> & dst) {
+  START (copy);
+  for (auto i : vars)
+    dst[i] = phases.saved[i];
+  STOP (copy);
+}
+
+void Internal::clear_phases (vector<signed char> & dst) {
+  START (copy);
+  for (auto i : vars)
+    dst[i] = 0;
+  STOP (copy);
+}
+
+void Internal::phase (int lit) {
+  const int idx = vidx (lit);
+  signed char old_forced_phase = phases.forced[idx];
+  signed char new_forced_phase = sign (lit);
+  if (old_forced_phase == new_forced_phase) return;
+  if (old_forced_phase)
+    LOG ("overwriting old forced phase %d", old_forced_phase * idx);
+  LOG ("new forced phase %d", new_forced_phase * idx);
+  phases.forced[idx] = new_forced_phase;
+}
+
+void Internal::unphase (int lit) {
+  const int idx = vidx (lit);
+  signed char old_forced_phase = phases.forced[idx];
+  if (!old_forced_phase) return;
+  LOG ("clearing old forced phase %d", old_forced_phase * idx);
+  phases.forced[idx] = 0;
+}
+
+}
diff --git a/hCaD_V2/src/phases.hpp b/hCaD_V2/src/phases.hpp
new file mode 100644
index 0000000..4f7dc90
--- /dev/null
+++ b/hCaD_V2/src/phases.hpp
@@ -0,0 +1,19 @@
+#ifndef _phases_hpp_INCLUDED
+#define _phases_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Phases {
+
+  vector<signed char> best;    // The current largest trail phase.
+  vector<signed char> forced;  // Forced through 'phase'.
+  vector<signed char> min;     // The current minimum unsatisfied phase.
+  vector<signed char> prev;    // Previous during local search.
+  vector<signed char> saved;   // The actual saved phase.
+  vector<signed char> target;  // The current target phase.
+  vector<double> act;
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/probe.cpp b/hCaD_V2/src/probe.cpp
new file mode 100644
index 0000000..f85f5f1
--- /dev/null
+++ b/hCaD_V2/src/probe.cpp
@@ -0,0 +1,687 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Failed literal probing uses it's own propagation and assignment
+// functions.  It further provides on-the-fly generation of hyper binary
+// resolvents but only probes on roots of the binary implication graph.  The
+// search for failed literals is limited, but untried roots are kept until
+// the next time 'probe' is called.  Left over probes from the last attempt
+// and new probes are tried until the limit is hit or all are tried.
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::probing () {
+  if (!opts.probe) return false;
+  if (!preprocessing && !opts.inprocessing) return false;
+  if (preprocessing) assert (lim.preprocessing);
+  if (stats.probingphases &&
+      last.probe.reductions == stats.reductions) return false;
+  return lim.probe <= stats.conflicts;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline int Internal::get_parent_reason_literal (int lit) {
+  const int idx = vidx (lit);
+  int res = parents[idx];
+  if (lit < 0) res = -res;
+  return res;
+}
+
+inline void Internal::set_parent_reason_literal (int lit, int reason) {
+  const int idx = vidx (lit);
+  if (lit < 0) reason = -reason;
+  parents[idx] = reason;
+}
+
+/*------------------------------------------------------------------------*/
+
+// On-the-fly (dynamic) hyper binary resolution on decision level one can
+// make use of the fact that the implication graph is actually a tree.
+
+// Compute a dominator of two literals in the binary implication tree.
+
+int Internal::probe_dominator (int a, int b) {
+  require_mode (PROBE);
+  int l = a, k = b;
+  Var * u = &var (l), * v = &var (k);
+  assert (val (l) > 0), assert (val (k) > 0);
+  assert (u->level == 1), assert (v->level == 1);
+  while (l != k) {
+    if (u->trail > v->trail) swap (l, k), swap (u, v);
+    if (!get_parent_reason_literal (l)) return l;
+    int parent = get_parent_reason_literal (k);
+    assert  (parent), assert (val (parent) > 0);
+    v = &var (k = parent);
+    assert (v->level == 1);
+  }
+  LOG ("dominator %d of %d and %d", l, a, b);
+  assert (val (l) > 0);
+  return l;
+}
+
+// The idea of dynamic on-the-fly hyper-binary resolution came up in the
+// PrecoSAT solver, where it originally was used on all decision levels.
+
+// It turned out, that most of the hyper-binary resolvents were generated
+// during probing on decision level one anyhow.  Thus this version is
+// specialized to decision level one, where actually all long (non-binary)
+// forcing clauses can be resolved to become binary.  So if we find a clause
+// which would force a new assignment at decision level one during probing
+// we resolve it (the 'reason' argument) to obtain a hyper binary resolvent.
+// It consists of the still unassigned literal (the new unit) and the
+// negation of the unique closest dominator of the negation of all (false)
+// literals in the clause (which has to exist on decision level one).
+
+// There are two special cases which should be mentioned:
+//
+//   (A) The reason is already a binary clause in a certain sense, since all
+//   its unwatched literals are root level fixed to false.  In this
+//   situation it would be better to shrink the clause immediately instead
+//   of adding a new clause consisting only of the watched literals.
+//   However, this would happen during the next garbage collection anyhow.
+//
+//   (B) The resolvent subsumes the original reason clause. This is
+//   equivalent to the property that the negated dominator is contained in
+//   the original reason.  Again one could in principle shrink the clause.
+//
+// Note that (A) is actually subsumed by (B).  The possible optimization to
+// shrink the clause on-the-fly is difficult (need to update 'blit' and
+// 'binary' of the other watch at least) and also not really that important.
+// For (B) we simply add the new binary resolvent and mark the old subsumed
+// clause as garbage instead.  And since in the situation of (A) the
+// shrinking will be performed at the next  garbage collection anyhow, we
+// do not change clauses in (A).
+
+// The hyper binary resolvent clause is redundant unless it subsumes the
+// original reason and that one is irredundant.
+
+// If the option 'opts.probehbr' is 'false', we actually do not add the new
+// hyper binary resolvent, but simply pretend we would have added it and
+// still return the dominator as new reason / parent for the new unit.
+
+// Finally note that adding clauses changes the watches of the propagated
+// literal and thus we can not use standard iterators during probing but
+// need to fall back to indices.  One watch for the hyper binary resolvent
+// clause is added at the end of the currently propagated watches, but its
+// watch is a binary watch and will be skipped during propagating long
+// clauses anyhow.
+
+inline int Internal::hyper_binary_resolve (Clause * reason) {
+  require_mode (PROBE);
+  assert (level == 1);
+  assert (reason->size > 2);
+  const const_literal_iterator end = reason->end ();
+  const int * lits = reason->literals;
+  const_literal_iterator k;
+#ifndef NDEBUG
+  // First literal unassigned, all others false.
+  assert (!val (lits[0]));
+  for (k = lits + 1; k != end; k++) assert (val (*k) < 0);
+  assert (var (lits[1]).level == 1);
+#endif
+  LOG (reason, "hyper binary resolving");
+  stats.hbrs++;
+  stats.hbrsizes += reason->size;
+  const int lit = lits[1];
+  int dom = -lit, non_root_level_literals = 0;
+  for (k = lits + 2; k != end; k++) {
+    const int other = -*k;
+    assert (val (other) > 0);
+    if (!var (other).level) continue;
+    dom = probe_dominator (dom, other);
+    non_root_level_literals++;
+  }
+  if (non_root_level_literals && opts.probehbr) { // !(A)
+    bool contained = false;
+    for (k = lits + 1; !contained && k != end; k++)
+      contained = (*k == -dom);
+    const bool red = !contained || reason->redundant;
+    if (red) stats.hbreds++;
+    LOG ("new %s hyper binary resolvent %d %d",
+      (red ? "redundant" : "irredundant"), -dom, lits[0]);
+    assert (clause.empty ());
+    clause.push_back (-dom);
+    clause.push_back (lits[0]);
+    Clause * c = new_hyper_binary_resolved_clause (red, 2);
+    if (red) c->hyper = true;
+    clause.clear ();
+    if (contained) {
+      stats.hbrsubs++;
+      LOG (reason, "subsumed original");
+      mark_garbage (reason);
+    }
+  }
+  return dom;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The following functions 'probe_assign' and 'probe_propagate' are used for
+// propagating during failed literal probing in simplification mode, as
+// replacement of the generic propagation routine 'propagate' and
+// 'search_assign'.
+
+// The code is mostly copied from 'propagate.cpp' and specialized.  We only
+// comment on the differences.  More explanations are in 'propagate.cpp'.
+
+inline void Internal::probe_assign (int lit, int parent) {
+  require_mode (PROBE);
+  int idx = vidx (lit);
+  assert (!vals[idx]);
+  assert (!flags (idx).eliminated () || !parent);
+  assert (!parent || val (parent) > 0);
+  Var & v = var (idx);
+  v.level = level;
+  v.trail = (int) trail.size ();
+  set_parent_reason_literal (lit, parent);
+  if (!level) learn_unit_clause (lit);
+  else assert (level == 1);
+  const signed char tmp = sign (lit);
+  vals[idx] = tmp;
+  vals[-idx] = -tmp;
+  assert (val (lit) > 0);
+  assert (val (-lit) < 0);
+  trail.push_back (lit);
+
+  // Do not save the current phase during inprocessing but remember the
+  // number of units on the trail of the last time this literal was
+  // assigned.  This allows us to avoid some redundant failed literal
+  // probing attempts.  Search for 'propfixed' in 'probe.cpp' for details.
+  //
+  if (level) propfixed (lit) = stats.all.fixed;
+
+      if (parent) LOG ("probe assign %d parent %d", lit, parent);
+  else if (level) LOG ("probe assign %d probe", lit);
+  else            LOG ("probe assign %d negated failed literal UIP", lit);
+}
+
+void Internal::probe_assign_decision (int lit) {
+  require_mode (PROBE);
+  assert (!level);
+  assert (propagated == trail.size ());
+  level++;
+  control.push_back (Level (lit, trail.size ()));
+  probe_assign (lit, 0);
+}
+
+void Internal::probe_assign_unit (int lit) {
+  require_mode (PROBE);
+  assert (!level);
+  assert (active (lit));
+  probe_assign (lit, 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is essentially the same as 'propagate' except that we prioritize and
+// always propagate binary clauses first (see our CPAIOR'13 paper on tree
+// based look ahead), then immediately stop at a conflict and of course use
+// 'probe_assign' instead of 'search_assign'.  The binary propagation part
+// is factored out too.  If a new unit on decision level one is found we
+// perform hyper binary resolution and thus actually build an implication
+// tree instead of a DAG.  Statistics counters are also different.
+
+inline void Internal::probe_propagate2 () {
+  require_mode (PROBE);
+  while (propagated2 != trail.size ()) {
+    const int lit = -trail[propagated2++];
+    LOG ("probe propagating %d over binary clauses", -lit);
+    Watches & ws = watches (lit);
+    for (const auto & w : ws) {
+      if (!w.binary ()) continue;
+      const signed char b = val (w.blit);
+      if (b > 0) continue;
+      if (b < 0) conflict = w.clause;                   // but continue
+      else probe_assign (w.blit, -lit);
+    }
+  }
+}
+
+bool Internal::probe_propagate () {
+  require_mode (PROBE);
+  assert (!unsat);
+  START (propagate);
+  int64_t before = propagated2 = propagated;
+  while (!conflict) {
+    if (propagated2 != trail.size ()) probe_propagate2 ();
+    else if (propagated != trail.size ()) {
+      const int lit = -trail[propagated++];
+      LOG ("probe propagating %d over large clauses", -lit);
+      Watches & ws = watches (lit);
+      size_t i = 0, j = 0;
+      while (i != ws.size ()) {
+        const Watch w = ws[j++] = ws[i++];
+        if (w.binary ()) continue;
+        const signed char b = val (w.blit);
+        if (b > 0) continue;
+        if (w.clause->garbage) continue;
+        const literal_iterator lits = w.clause->begin ();
+        const int other = lits[0]^lits[1]^lit;
+        //lits[0] = other, lits[1] = lit;
+        const signed char u = val (other);
+        if (u > 0) ws[j-1].blit = other;
+        else {
+          const int size = w.clause->size;
+          const const_literal_iterator end = lits + size;
+          const literal_iterator middle = lits + w.clause->pos;
+          literal_iterator k = middle;
+          int r = 0;
+          signed char v = -1;
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+          if (v < 0) {
+            k = lits + 2;
+            assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+          w.clause->pos = k - lits;
+          assert (lits + 2 <= k), assert (k <= w.clause->end ());
+          if (v > 0) ws[j-1].blit = r;
+          else if (!v) {
+            LOG (w.clause, "unwatch %d in", r);
+            *k = lit;
+            lits[0] = other;
+            lits[1] = r;
+            watch_literal (r, lit, w.clause);
+            j--;
+          } else if (!u) {
+            if (level == 1) {
+              lits[0] = other, lits[1] = lit;
+              int dom = hyper_binary_resolve (w.clause);
+              probe_assign (other, dom);
+            } else probe_assign_unit (other);
+            probe_propagate2 ();
+          } else conflict = w.clause;
+        }
+      }
+      if (j != i) {
+        while (i != ws.size ())
+          ws[j++] = ws[i++];
+        ws.resize (j);
+      }
+    } else break;
+  }
+  int64_t delta = propagated2 - before;
+  stats.propagations.probe += delta;
+  if (conflict) LOG (conflict, "conflict");
+  STOP (propagate);
+  return !conflict;
+}
+
+/*------------------------------------------------------------------------*/
+
+// This a specialized instance of 'analyze'.
+
+void Internal::failed_literal (int failed) {
+
+  LOG ("analyzing failed literal probe %d", failed);
+  stats.failed++;
+  stats.probefailed++;
+
+  assert (!unsat);
+  assert (conflict);
+  assert (level == 1);
+  assert (analyzed.empty ());
+
+  START (analyze);
+
+  LOG (conflict, "analyzing failed literal conflict");
+
+  int uip = 0;
+  for (const auto & lit : *conflict) {
+    const int other = -lit;
+    if (!var (other).level) continue;
+    uip = uip ? probe_dominator (uip, other) : other;
+  }
+  LOG ("found probing UIP %d", uip);
+  assert (uip);
+
+  vector<int> work;
+  int parent = uip;
+  while (parent != failed) {
+    const int next = get_parent_reason_literal (parent);
+    parent = next;
+    assert (parent);
+    work.push_back (parent);
+  }
+
+  backtrack ();
+  clear_analyzed_literals ();
+  conflict = 0;
+
+  assert (!val (uip));
+  probe_assign_unit (-uip);
+
+  if (!probe_propagate ()) learn_empty_clause ();
+
+  while (!unsat && !work.empty ()) {
+    const int parent = work.back ();
+    work.pop_back ();
+    const signed char tmp = val (parent);
+    if (tmp < 0) continue;
+    if (tmp > 0) {
+      LOG ("clashing failed parent %d", parent);
+      learn_empty_clause ();
+    } else {
+      LOG ("found unassigned failed parent %d", parent);
+      probe_assign_unit (-parent);
+      if (!probe_propagate ()) learn_empty_clause ();
+    }
+  }
+  erase_vector (work);
+
+  STOP (analyze);
+
+  assert (unsat || val (failed) < 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::is_binary_clause (Clause * c, int & a, int & b) {
+  assert (!level);
+  if (c->garbage) return false;
+  int first = 0, second = 0;
+  for (const auto & lit : *c) {
+    const signed char tmp = val (lit);
+    if (tmp > 0) return false;
+    if (tmp < 0) continue;
+    if (second) return false;
+    if (first) second = lit;
+    else first = lit;
+  }
+  if (!second) return false;
+  a = first, b = second;
+  return true;
+}
+
+// We probe on literals first, which occur more often negated and thus we
+// sort the 'probes' stack in such a way that literals which occur negated
+// less frequently come first.  Probes are taken from the back of the stack.
+
+struct probe_negated_noccs_rank {
+  Internal * internal;
+  probe_negated_noccs_rank (Internal * i) : internal (i) { }
+  typedef size_t Type;
+  Type operator () (int a) const { return internal->noccs (-a); }
+};
+
+// Fill the 'probes' schedule.
+
+void Internal::generate_probes () {
+
+  assert (probes.empty ());
+
+  // First determine all the literals which occur in binary clauses. It is
+  // way faster to go over the clauses once, instead of walking the watch
+  // lists for each literal.
+  //
+  init_noccs ();
+  for (const auto & c : clauses) {
+    int a, b;
+    if (!is_binary_clause (c, a, b)) continue;
+    noccs (a)++;
+    noccs (b)++;
+  }
+
+  for (auto idx : vars) {
+
+    // Then focus on roots of the binary implication graph, which are
+    // literals occurring negatively in a binary clause, but not positively.
+    // If neither 'idx' nor '-idx' is a root it makes less sense to probe
+    // this variable.
+
+    // This argument requires that equivalent literal substitution through
+    // 'decompose' is performed, because otherwise there might be 'cyclic
+    // roots' which are not tried, i.e., -1 2 0, 1 -2 0, 1 2 3 0, 1 2 -3 0.
+
+    const bool have_pos_bin_occs = noccs (idx) > 0;
+    const bool have_neg_bin_occs = noccs (-idx) > 0;
+
+    if (have_pos_bin_occs == have_neg_bin_occs) continue;
+
+    int probe = have_neg_bin_occs ? idx : -idx;
+
+    // See the discussion where 'propfixed' is used below.
+    //
+    if (propfixed (probe) >= stats.all.fixed) continue;
+
+    LOG ("scheduling probe %d negated occs %" PRId64 "", probe, noccs (-probe));
+    probes.push_back (probe);
+  }
+
+  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
+
+  reset_noccs ();
+  shrink_vector (probes);
+
+  PHASE ("probe-round", stats.probingrounds, "scheduled %zd literals %.0f%%",
+    probes.size (), percent (probes.size (), 2u*max_var));
+}
+
+// Follow the ideas in 'generate_probes' but flush non root probes and
+// reorder remaining probes.
+
+void Internal::flush_probes () {
+
+  assert (!probes.empty ());
+
+  init_noccs ();
+  for (const auto & c : clauses) {
+    int a, b;
+    if (!is_binary_clause (c, a, b)) continue;
+    noccs (a)++;
+    noccs (b)++;
+  }
+
+  const auto eop = probes.end ();
+  auto j = probes.begin ();
+  for (auto i = j; i != eop; i++) {
+    int lit = *i;
+    if (!active (lit)) continue;
+    const bool have_pos_bin_occs = noccs (lit) > 0;
+    const bool have_neg_bin_occs = noccs (-lit) > 0;
+    if (have_pos_bin_occs == have_neg_bin_occs) continue;
+    if (have_pos_bin_occs) lit = -lit;
+    assert (!noccs (lit)), assert (noccs (-lit) > 0);
+    if (propfixed (lit) >= stats.all.fixed) continue;
+    LOG ("keeping probe %d negated occs %" PRId64 "", lit, noccs (-lit));
+    *j++ = lit;
+  }
+  size_t remain = j - probes.begin ();
+#ifndef QUIET
+  size_t flushed = probes.size () - remain;
+#endif
+  probes.resize (remain);
+
+  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
+
+  reset_noccs ();
+  shrink_vector (probes);
+
+  PHASE ("probe-round", stats.probingrounds,
+    "flushed %zd literals %.0f%% remaining %zd",
+    flushed, percent (flushed, remain + flushed), remain);
+}
+
+int Internal::next_probe () {
+
+  int generated = 0;
+
+  for (;;) {
+
+    if (probes.empty ()) {
+      if (generated++) return 0;
+      generate_probes ();
+    }
+
+    while (!probes.empty ()) {
+
+      int probe = probes.back ();
+      probes.pop_back ();
+
+      // Eliminated or assigned.
+      //
+      if (!active (probe)) continue;
+
+      // There is now new unit since the last time we propagated this probe,
+      // thus we propagated it before without obtaining a conflict and
+      // nothing changed since then.  Thus there is no need to propagate it
+      // again.  This observation was independently made by Partik Simons
+      // et.al. in the context of implementing 'smodels' (see for instance
+      // Alg. 4 in his JAIR article from 2002) and it has also been
+      // contributed to the thesis work of Yacine Boufkhad.
+      //
+      if (propfixed (probe) >= stats.all.fixed) continue;
+
+      return probe;
+    }
+  }
+}
+
+bool Internal::probe_round () {
+
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
+
+  START_SIMPLIFIER (probe, PROBE);
+  stats.probingrounds++;
+
+  // Probing is limited in terms of non-probing propagations
+  // 'stats.propagations'. We allow a certain percentage 'opts.probereleff'
+  // (say %5) of probing propagations in each probing with a lower bound of
+  // 'opts.probmineff'.
+  //
+  int64_t delta = stats.propagations.search;
+  delta -= last.probe.propagations;
+  delta *= 1e-3 * opts.probereleff;
+  if (delta < opts.probemineff) delta = opts.probemineff;
+  if (delta > opts.probemaxeff) delta = opts.probemaxeff;
+  delta += 2l * active ();
+
+  PHASE ("probe-round", stats.probingrounds,
+    "probing limit of %" PRId64 " propagations ", delta);
+
+  int64_t limit = stats.propagations.probe + delta;
+
+  int old_failed = stats.failed;
+#ifndef QUIET
+  int64_t old_probed = stats.probed;
+#endif
+  int64_t old_hbrs = stats.hbrs;
+
+  if (!probes.empty ()) flush_probes ();
+
+  // We reset 'propfixed' since there was at least another conflict thus
+  // a new learned clause, which might produce new propagations (and hyper
+  // binary resolvents).  During 'generate_probes' we keep the old value.
+  //
+  for (auto idx : vars)
+    propfixed (idx) = propfixed (-idx) = -1;
+
+  assert (unsat || propagated == trail.size ());
+  propagated = propagated2 = trail.size ();
+
+  int probe;
+  while (!unsat &&
+         !terminated_asynchronously () &&
+         stats.propagations.probe < limit &&
+         (probe = next_probe ())) {
+    stats.probed++;
+    LOG ("probing %d", probe);
+    probe_assign_decision (probe);
+    if (probe_propagate ()) backtrack ();
+    else failed_literal (probe);
+  }
+
+  if (unsat) LOG ("probing derived empty clause");
+  else if (propagated < trail.size ()) {
+    LOG ("probing produced %zd units", (size_t)(trail.size () - propagated));
+    if (!propagate ()) {
+      LOG ("propagating units after probing results in empty clause");
+      learn_empty_clause ();
+    } else sort_watches ();
+  }
+
+  int failed = stats.failed - old_failed;
+#ifndef QUIET
+  int64_t probed = stats.probed - old_probed;
+#endif
+  int64_t hbrs = stats.hbrs - old_hbrs;
+
+  PHASE ("probe-round", stats.probingrounds,
+    "probed %" PRId64 " and found %d failed literals", probed, failed);
+
+  if (hbrs)
+    PHASE ("probe-round", stats.probingrounds,
+      "found %" PRId64 " hyper binary resolvents", hbrs);
+
+  STOP_SIMPLIFIER (probe, PROBE);
+
+  report ('p', !opts.reportall && !(unsat + failed + hbrs));
+
+  return !unsat && failed;
+}
+
+/*------------------------------------------------------------------------*/
+
+void CaDiCaL::Internal::probe (bool update_limits) {
+
+  if (unsat) return;
+  if (level) backtrack ();
+  if (!propagate ()) { learn_empty_clause (); return; }
+
+  stats.probingphases++;
+
+  const int before = active ();
+
+  // We trigger equivalent literal substitution (ELS) before ...
+  //
+  decompose ();
+
+  if (ternary ())       // If we derived a binary clause
+    decompose ();       // then start another round of ELS.
+
+  // Remove duplicated binary clauses and perform in essence hyper unary
+  // resolution, i.e., derive the unit '2' from '1 2' and '-1 2'.
+  //
+  mark_duplicated_binary_clauses_as_garbage ();
+
+  for (int round = 1; round <= opts.proberounds; round++)
+    if (!probe_round ())
+      break;
+
+  decompose ();         // ... and (ELS) afterwards.
+
+  last.probe.propagations = stats.propagations.search;
+
+  if (!update_limits) return;
+
+  const int after = active ();
+  const int removed = before - after;
+  assert (removed >= 0);
+
+  if (removed) {
+    stats.probesuccess++;
+    PHASE ("probe-phase", stats.probingphases,
+      "successfully removed %d active variables %.0f%%",
+      removed, percent (removed, before));
+  } else
+    PHASE ("probe-phase", stats.probingphases,
+      "could not remove any active variable");
+
+  const int64_t delta = opts.probeint * (stats.probingphases + 1);
+  lim.probe = stats.conflicts + delta;
+
+  PHASE ("probe-phase", stats.probingphases,
+    "new limit at %" PRId64 " conflicts after %" PRId64 " conflicts",
+    lim.probe, delta);
+
+  last.probe.reductions = stats.reductions;
+}
+
+}
diff --git a/hCaD_V2/src/profile.cpp b/hCaD_V2/src/profile.cpp
new file mode 100644
index 0000000..afd202a
--- /dev/null
+++ b/hCaD_V2/src/profile.cpp
@@ -0,0 +1,108 @@
+#ifndef QUIET
+
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Initialize all profile counters with constant name and profiling level.
+
+Profiles::Profiles (Internal * s)
+:
+  internal (s)
+#define PROFILE(NAME, LEVEL) \
+  , NAME (#NAME, LEVEL)
+  PROFILES
+#undef PROFILE
+{
+}
+
+void Internal::start_profiling (Profile & profile, double s) {
+  assert (profile.level <= opts.profile);
+  assert (!profile.active);
+  profile.started = s;
+  profile.active = true;
+}
+
+void Internal::stop_profiling (Profile & profile, double s) {
+  assert (profile.level <= opts.profile);
+  assert (profile.active);
+  profile.value += s - profile.started;
+  profile.active = false;
+}
+
+double Internal::update_profiles () {
+  double now = time ();
+# define PROFILE(NAME,LEVEL) \
+do { \
+  Profile & profile = profiles.NAME; \
+  if (profile.active) { \
+    assert (profile.level <= opts.profile); \
+    profile.value += now - profile.started; \
+    profile.started = now; \
+  } \
+} while (0);
+  PROFILES
+# undef PROFILE
+  return now;
+}
+
+double Internal::solve_time () {
+  (void) update_profiles ();
+  return profiles.solve.value;
+}
+
+#define PRT(S,T) \
+  MSG ("%s" S "%s", tout.magenta_code (), T, tout.normal_code ())
+
+void Internal::print_profile () {
+  double now = update_profiles ();
+  const char * time_type = opts.realtime ? "real" : "process";
+  SECTION ("run-time profiling");
+  PRT ("%s time taken by individual solving procedures", time_type);
+  PRT ("(percentage relative to %s time for solving)", time_type);
+  LINE ();
+  const size_t size = sizeof profiles / sizeof (Profile);
+  struct Profile * profs[size];
+  size_t n = 0;
+#define PROFILE(NAME,LEVEL) \
+do { \
+  if (LEVEL > opts.profile) break; \
+  Profile * p = &profiles.NAME; \
+  if (p == &profiles.solve) break; \
+  if (!profiles.NAME.value && \
+      p != &profiles.parse && \
+      p != &profiles.search && \
+      p != &profiles.simplify) break; \
+  profs[n++] = p; \
+} while (0);
+  PROFILES
+#undef PROFILE
+
+  assert (n <= size);
+
+  // Explicit bubble sort to avoid heap allocation since 'print_profile'
+  // is also called during catching a signal after out of heap memory.
+  // This only makes sense if 'profs' is allocated on the stack, and
+  // not the heap, which should be the case.
+
+  double solve = profiles.solve.value;
+
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = i + 1; j < n; j++)
+      if (profs[j]->value > profs[i]->value)
+        swap (profs[i], profs[j]);
+    MSG ("%12.2f %7.2f%% %s",
+      profs[i]->value, percent (profs[i]->value, solve), profs[i]->name);
+  }
+
+  MSG ("  =================================");
+  MSG ("%12.2f %7.2f%% solve", solve, percent (solve, now));
+
+  LINE ();
+  PRT ("last line shows %s time for solving", time_type);
+  PRT ("(percentage relative to total %s time)", time_type);
+}
+
+}
+
+#endif // ifndef QUIET
diff --git a/hCaD_V2/src/profile.hpp b/hCaD_V2/src/profile.hpp
new file mode 100644
index 0000000..9ec3ed4
--- /dev/null
+++ b/hCaD_V2/src/profile.hpp
@@ -0,0 +1,258 @@
+#ifndef _profiles_h_INCLUDED
+#define _profiles_h_INCLUDED
+
+/*------------------------------------------------------------------------*/
+#ifndef QUIET
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+struct Internal;
+
+/*------------------------------------------------------------------------*/
+
+// The solver contains some built in profiling (even for optimized code).
+// The idea is that even without using external tools it is possible to get
+// an overview of where time is spent.  This is enabled with the option
+// 'profile', e.g., you might want to use '--profile=3', or even higher
+// values for more detailed profiling information.  Currently the default is
+// '--profile=2', which should only induce a tiny profiling overhead.
+//
+// Profiling has a Heisenberg effect, since we rely on calling 'getrusage'
+// instead of using profile counters and sampling.  For functions which are
+// executed many times, this overhead is substantial (say 10%-20%).  For
+// functions which are not executed many times there is in essence no
+// overhead in measuring time spent in them.  These get a smaller profiling
+// level, which is the second argument in the 'PROFILE' macro below.  Thus
+// using '--profile=1' for instance should not add any penalty to the
+// run-time, while '--profile=3' and higher levels slow down the solver.
+//
+// To profile say 'foo', just add another line 'PROFILE(foo,LEVEL)' and wrap
+// the code to be profiled within a 'START (foo)' / 'STOP (foo)' block.
+
+/*------------------------------------------------------------------------*/
+
+// Profile counters for functions which are not compiled in should be
+// removed. This is achieved by adding a wrapper macro for them here.
+
+/*------------------------------------------------------------------------*/
+
+#define PROFILES \
+PROFILE(analyze,3) \
+PROFILE(backward,3) \
+PROFILE(block,2) \
+PROFILE(bump,4) \
+PROFILE(checking,2) \
+PROFILE(cdcl,1) \
+PROFILE(collect,3) \
+PROFILE(compact,3) \
+PROFILE(condition,2) \
+PROFILE(connect,3) \
+PROFILE(copy,4) \
+PROFILE(cover,2) \
+PROFILE(decide,3) \
+PROFILE(decompose,3) \
+PROFILE(elim,2) \
+PROFILE(extend,3) \
+PROFILE(instantiate,2) \
+PROFILE(lucky,2) \
+PROFILE(lookahead,2) \
+PROFILE(minimize,4) \
+PROFILE(shrink, 4) \
+PROFILE(parse,0) /*Set to '0' as 'opts.profile' might change in parsing*/ \
+PROFILE(probe,2) \
+PROFILE(deduplicate,3) \
+PROFILE(propagate,4) \
+PROFILE(reduce,3) \
+PROFILE(restart,3) \
+PROFILE(restore,2) \
+PROFILE(search,1) \
+PROFILE(solve,0) \
+PROFILE(stable,2) \
+PROFILE(preprocess,2) \
+PROFILE(simplify,1) \
+PROFILE(subsume,2) \
+PROFILE(ternary,2) \
+PROFILE(transred,3) \
+PROFILE(unstable,2) \
+PROFILE(vivify,2) \
+PROFILE(walk,2) \
+
+/*------------------------------------------------------------------------*/
+
+// See 'START' and 'STOP' in 'macros.hpp' too.
+
+struct Profile {
+
+  bool active;
+  double value;      // accumulated time
+  double started;    // started time if active
+  const char * name; // name of the profiled function (or 'phase')
+  const int level;   // allows to cheaply test if profiling is enabled
+
+  Profile (const char * n, int l) :
+    active (false), value (0), name (n), level (l) { }
+};
+
+struct Profiles {
+  Internal * internal;
+#define PROFILE(NAME, LEVEL) \
+  Profile NAME;
+  PROFILES
+#undef PROFILE
+  Profiles (Internal *);
+};
+
+}
+
+#define NON_QUIET_PROFILE_CODE(CODE) CODE
+
+#else // !defined(QUIET)
+
+#define NON_QUIET_PROFILE_CODE(CODE) /**/
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+// Macros for Profiling support and checking and changing the mode.
+
+#define START(P) \
+do { \
+  NON_QUIET_PROFILE_CODE ( \
+    if (internal->profiles.P.level <= internal->opts.profile) \
+      internal->start_profiling (internal->profiles.P, internal->time ()); \
+  ) \
+} while (0)
+
+#define STOP(P) \
+do { \
+  NON_QUIET_PROFILE_CODE ( \
+    if (internal->profiles.P.level <= internal->opts.profile) \
+      internal->stop_profiling (internal->profiles.P, internal->time ()); \
+  ) \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define START_SIMPLIFIER(S,M) \
+do { \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+  ) \
+  if (!preprocessing && !lookingahead) { \
+    NON_QUIET_PROFILE_CODE ( \
+      if (stable && internal->profiles.stable.level <= L) \
+        internal->stop_profiling (internal->profiles.stable, N); \
+      if (!stable && internal->profiles.unstable.level <= L) \
+        internal->stop_profiling (internal->profiles.unstable, N); \
+      if (internal->profiles.search.level <= L) \
+        internal->stop_profiling (internal->profiles.search, N); \
+    ) \
+    reset_mode (SEARCH); \
+  } \
+  NON_QUIET_PROFILE_CODE ( \
+    if (internal->profiles.simplify.level <= L) \
+      internal->start_profiling (internal->profiles.simplify, N); \
+    if (internal->profiles.S.level <= L) \
+      internal->start_profiling (internal->profiles.S, N); \
+  ) \
+  set_mode (SIMPLIFY); \
+  set_mode (M); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define STOP_SIMPLIFIER(S,M) \
+do { \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+    if (internal->profiles.S.level <= L) \
+      internal->stop_profiling (internal->profiles.S, N); \
+    if (internal->profiles.simplify.level <= L) \
+      internal->stop_profiling (internal->profiles.simplify, N); \
+  ) \
+  reset_mode (M); \
+  reset_mode (SIMPLIFY); \
+  if (!preprocessing && !lookingahead) { \
+    NON_QUIET_PROFILE_CODE ( \
+      if (internal->profiles.search.level <= L) \
+        internal->start_profiling (internal->profiles.search, N); \
+      if (stable && internal->profiles.stable.level <= L) \
+        internal->start_profiling (internal->profiles.stable, N); \
+      if (!stable && internal->profiles.unstable.level <= L) \
+        internal->start_profiling (internal->profiles.unstable, N); \
+    ) \
+    set_mode (SEARCH); \
+  } \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+// Used in 'walk' before calling 'walk_round' within the CDCL loop.
+
+#define START_INNER_WALK() \
+do { \
+  require_mode (SEARCH); \
+  assert (!preprocessing); \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+    if (stable && internal->profiles.stable.level <= L) \
+      internal->stop_profiling (internal->profiles.stable, N); \
+    if (!stable && internal->profiles.unstable.level <= L) \
+      internal->stop_profiling (internal->profiles.unstable, N); \
+    if (internal->profiles.walk.level <= L) \
+      internal->start_profiling (internal->profiles.walk, N); \
+  ) \
+  set_mode (WALK); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+// Used in 'walk' after calling 'walk_round' within the CDCL loop.
+
+#define STOP_INNER_WALK() \
+do { \
+  require_mode (SEARCH); \
+  assert (!preprocessing); \
+  reset_mode (WALK); \
+  NON_QUIET_PROFILE_CODE ( \
+    const double N = time (); \
+    const int L = internal->opts.profile; \
+    if (internal->profiles.walk.level <= L) \
+      internal->stop_profiling (internal->profiles.walk, N); \
+    if (stable && internal->profiles.stable.level <= L) \
+      internal->start_profiling (internal->profiles.stable, N); \
+    if (!stable && internal->profiles.unstable.level <= L) \
+      internal->start_profiling (internal->profiles.unstable, N); \
+  ) \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+// Used in 'local_search' before calling 'walk_round'.
+
+#define START_OUTER_WALK() \
+do { \
+  require_mode (SEARCH); \
+  assert (!preprocessing); \
+  NON_QUIET_PROFILE_CODE ( \
+    START (walk); \
+  ) \
+  set_mode (WALK); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+// Used in 'local_search' after calling 'walk_round'.
+
+#define STOP_OUTER_WALK() \
+do { \
+  require_mode (SEARCH); \
+  assert (!preprocessing); \
+  reset_mode (WALK); \
+  NON_QUIET_PROFILE_CODE ( \
+    STOP (walk); \
+  ) \
+} while (0)
+
+#endif // ifndef _profiles_h_INCLUDED
diff --git a/hCaD_V2/src/proof.cpp b/hCaD_V2/src/proof.cpp
new file mode 100644
index 0000000..9e8c060
--- /dev/null
+++ b/hCaD_V2/src/proof.cpp
@@ -0,0 +1,186 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+using namespace std;
+
+/*------------------------------------------------------------------------*/
+
+// Enable proof logging and checking by allocating a 'Proof' object.
+
+void Internal::new_proof_on_demand () {
+  if (!proof) {
+    proof = new Proof (this);
+    LOG ("connecting proof to internal solver");
+  }
+}
+
+// Enable proof tracing.
+
+void Internal::trace (File * file) {
+  assert (!tracer);
+  new_proof_on_demand ();
+  tracer = new Tracer (this, file, opts.binary);
+  LOG ("PROOF connecting proof tracer");
+  proof->connect (tracer);
+}
+
+// Enable proof checking.
+
+void Internal::check () {
+  assert (!checker);
+  new_proof_on_demand ();
+  checker = new Checker (this);
+  LOG ("PROOF connecting proof checker");
+  proof->connect (checker);
+}
+
+// We want to close a proof trace and stop checking as soon we are done.
+
+void Internal::close_trace () {
+  assert (tracer);
+  tracer->close ();
+}
+
+// We can flush a proof trace file before actually closing it.
+
+void Internal::flush_trace () {
+  assert (tracer);
+  tracer->flush ();
+}
+
+/*------------------------------------------------------------------------*/
+
+Proof::Proof (Internal * s) : internal (s) { LOG ("PROOF new"); }
+
+Proof::~Proof () { LOG ("PROOF delete"); }
+
+/*------------------------------------------------------------------------*/
+
+inline void Proof::add_literal (int internal_lit) {
+  const int external_lit = internal->externalize (internal_lit);
+  clause.push_back (external_lit);
+}
+
+inline void Proof::add_literals (Clause * c) {
+  for (auto const & lit : * c)
+    add_literal (lit);
+}
+
+inline void Proof::add_literals (const vector<int> & c) {
+  for (auto const & lit : c)
+    add_literal (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Proof::add_original_clause (const vector<int> & c) {
+  LOG (c, "PROOF adding original internal clause");
+  add_literals (c);
+  add_original_clause ();
+}
+
+void Proof::add_derived_empty_clause () {
+  LOG ("PROOF adding empty clause");
+  assert (clause.empty ());
+  add_derived_clause ();
+}
+
+void Proof::add_derived_unit_clause (int internal_unit) {
+  LOG ("PROOF adding unit clause %d", internal_unit);
+  assert (clause.empty ());
+  add_literal (internal_unit);
+  add_derived_clause ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Proof::add_derived_clause (Clause * c) {
+  LOG (c, "PROOF adding to proof derived");
+  assert (clause.empty ());
+  add_literals (c);
+  add_derived_clause ();
+}
+
+void Proof::delete_clause (Clause * c) {
+  LOG (c, "PROOF deleting from proof");
+  assert (clause.empty ());
+  add_literals (c);
+  delete_clause ();
+}
+
+void Proof::delete_clause (const vector<int> & c) {
+  LOG (c, "PROOF deleting from proof");
+  assert (clause.empty ());
+  add_literals (c);
+  delete_clause ();
+}
+
+void Proof::add_derived_clause (const vector<int> & c) {
+  LOG (internal->clause, "PROOF adding derived clause");
+  assert (clause.empty ());
+  for (const auto & lit : c)
+    add_literal (lit);
+  add_derived_clause ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// During garbage collection clauses are shrunken by removing falsified
+// literals. To avoid copying the clause, we provide a specialized tracing
+// function here, which traces the required 'add' and 'remove' operations.
+
+void Proof::flush_clause (Clause * c) {
+  LOG (c, "PROOF flushing falsified literals in");
+  assert (clause.empty ());
+  for (int i = 0; i < c->size; i++) {
+    int internal_lit = c->literals[i];
+    if (internal->fixed (internal_lit) < 0) continue;
+    add_literal (internal_lit);
+  }
+  add_derived_clause ();
+  delete_clause (c);
+}
+
+// While strengthening clauses, e.g., through self-subsuming resolutions,
+// during subsumption checking, we have a similar situation, except that we
+// have to remove exactly one literal.  Again the following function allows
+// to avoid copying the clause and instead provides tracing of the required
+// 'add' and 'remove' operations.
+
+void Proof::strengthen_clause (Clause * c, int remove) {
+  LOG (c, "PROOF strengthen by removing %d in", remove);
+  assert (clause.empty ());
+  for (int i = 0; i < c->size; i++) {
+    int internal_lit = c->literals[i];
+    if (internal_lit == remove) continue;
+    add_literal (internal_lit);
+  }
+  add_derived_clause ();
+  delete_clause (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Proof::add_original_clause () {
+  LOG (clause, "PROOF adding original external clause");
+  for (size_t i = 0; i < observers.size (); i++)
+    observers[i]->add_original_clause (clause);
+  clause.clear ();
+}
+
+void Proof::add_derived_clause () {
+  LOG (clause, "PROOF adding derived external clause");
+  for (size_t i = 0; i < observers.size (); i++)
+    observers[i]->add_derived_clause (clause);
+  clause.clear ();
+}
+
+void Proof::delete_clause () {
+  LOG (clause, "PROOF deleting external clause");
+  for (size_t i = 0; i < observers.size (); i++)
+    observers[i]->delete_clause (clause);
+  clause.clear ();
+}
+
+}
diff --git a/hCaD_V2/src/proof.hpp b/hCaD_V2/src/proof.hpp
new file mode 100644
index 0000000..05ae609
--- /dev/null
+++ b/hCaD_V2/src/proof.hpp
@@ -0,0 +1,64 @@
+#ifndef _proof_h_INCLUDED
+#define _proof_h_INCLUDED
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+class File;
+struct Clause;
+struct Internal;
+class Observer;
+
+/*------------------------------------------------------------------------*/
+
+// Provides proof checking and writing through observers.
+
+class Proof {
+
+  Internal * internal;
+
+  vector<int> clause;           // of external literals
+  vector<Observer *> observers; // owned, so deleted in destructor
+
+  void add_literal (int internal_lit);  // add to 'clause'
+  void add_literals (Clause *);         // add to 'clause'
+
+  void add_literals (const vector<int> &);      // ditto
+
+  void add_original_clause ();  // notify observers of original clauses
+  void add_derived_clause ();   // notify observers of derived clauses
+  void delete_clause ();        // notify observers of deleted clauses
+
+public:
+
+  Proof (Internal *);
+  ~Proof ();
+
+  void connect (Observer * v) { observers.push_back (v); }
+
+  // Add original clauses to the proof (for online proof checking).
+  //
+  void add_original_clause (const vector<int> &);
+
+  // Add derived (such as learned) clauses to the proof.
+  //
+  void add_derived_empty_clause ();
+  void add_derived_unit_clause (int unit);
+  void add_derived_clause (Clause *);
+  void add_derived_clause (const vector<int> &);
+
+  void delete_clause (const vector<int> &);
+  void delete_clause (Clause *);
+
+  // These two actually pretend to add and remove a clause.
+  //
+  void flush_clause (Clause *);           // remove falsified literals
+  void strengthen_clause (Clause *, int); // remove second argument
+
+  void flush ();
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/propagate.cpp b/hCaD_V2/src/propagate.cpp
new file mode 100644
index 0000000..45e38e9
--- /dev/null
+++ b/hCaD_V2/src/propagate.cpp
@@ -0,0 +1,382 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// We are using the address of 'decision_reason' as pseudo reason for
+// decisions to distinguish assignment decisions from other assignments.
+// Before we added chronological backtracking all learned units were
+// assigned at decision level zero ('Solver.level == 0') and we just used a
+// zero pointer as reason.  After allowing chronological backtracking units
+// were also assigned at higher decision level (but with assignment level
+// zero), and it was not possible anymore to just distinguish the case
+// 'unit' versus 'decision' by just looking at the current level.  Both had
+// a zero pointer as reason.  Now only units have a zero reason and
+// decisions need to use the pseudo reason 'decision_reason'.
+
+static Clause decision_reason_clause;
+static Clause * decision_reason = &decision_reason_clause;
+
+// If chronological backtracking is used the actual assignment level might
+// be lower than the current decision level. In this case the assignment
+// level is defined as the maximum level of the literals in the reason
+// clause except the literal for which the clause is a reason.  This
+// function determines this assignment level. For non-chronological
+// backtracking as in classical CDCL this function always returns the
+// current decision level, the concept of assignment level does not make
+// sense, and accordingly this function can be skipped.
+
+inline int Internal::assignment_level (int lit, Clause * reason) {
+
+  assert (opts.chrono);
+  if (!reason) return level;
+
+  int res = 0;
+
+  for (const auto & other : *reason) {
+    if (other == lit) continue;
+    assert (val (other));
+    int tmp = var (other).level;
+    if (tmp > res) res = tmp;
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void Internal::search_assign (int lit, Clause * reason) {
+
+  if (level) require_mode (SEARCH);
+  if(opts.psids) bump_pol_sc(lit);
+  const int idx = vidx (lit);
+  assert (!vals[idx]);
+  assert (!flags (idx).eliminated () || reason == decision_reason);
+  Var & v = var (idx);
+  int lit_level;
+
+  // The following cases are explained in the two comments above before
+  // 'decision_reason' and 'assignment_level'.
+  //
+  if (!reason) lit_level = 0;   // unit
+  else if (reason == decision_reason) lit_level = level, reason = 0;
+  else if (opts.chrono) lit_level = assignment_level (lit, reason);
+  else lit_level = level;
+  if (!lit_level) reason = 0;
+
+  v.level = lit_level;
+  v.trail = (int) trail.size ();
+  v.reason = reason;
+  if (!lit_level) learn_unit_clause (lit);  // increases 'stats.fixed'
+  const signed char tmp = sign (lit);
+  vals[idx] = tmp;
+  vals[-idx] = -tmp;
+  assert (val (lit) > 0);
+  assert (val (-lit) < 0);
+  if (!searching_lucky_phases)
+    phases.saved[idx] = tmp;                // phase saving during search
+  trail.push_back (lit);
+#ifdef LOGGING
+  if (!lit_level) LOG ("root-level unit assign %d @ 0", lit);
+  else LOG (reason, "search assign %d @ %d", lit, lit_level);
+#endif
+
+  if (watching ()) {
+    const Watches & ws = watches (-lit);
+    if (!ws.empty ()) {
+      const Watch & w = ws[0];
+      __builtin_prefetch (&w, 0, 1);
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// External versions of 'search_assign' which are not inlined.  They either
+// are used to assign unit clauses on the root-level, in 'decide' to assign
+// a decision or in 'analyze' to assign the literal 'driven' by a learned
+// clause.  This happens far less frequently than the 'search_assign' above,
+// which is called directly in 'propagate' below and thus is inlined.
+
+void Internal::assign_unit (int lit) {
+  assert (!level);
+  search_assign (lit, 0);
+}
+
+// Just assume the given literal as decision (increase decision level and
+// assign it).  This is used below in 'decide'.
+
+void Internal::search_assume_decision (int lit) {
+  require_mode (SEARCH);
+  assert (propagated == trail.size ());
+  level++;
+  control.push_back (Level (lit, trail.size ()));
+  LOG ("search decide %d", lit);
+  search_assign (lit, decision_reason);
+}
+
+void Internal::search_assign_driving (int lit, Clause * c) {
+  require_mode (SEARCH);
+  search_assign (lit, c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// The 'propagate' function is usually the hot-spot of a CDCL SAT solver.
+// The 'trail' stack saves assigned variables and is used here as BFS queue
+// for checking clauses with the negation of assigned variables for being in
+// conflict or whether they produce additional assignments.
+
+// This version of 'propagate' uses lazy watches and keeps two watched
+// literals at the beginning of the clause.  We also use 'blocking literals'
+// to reduce the number of times clauses have to be visited (2008 JSAT paper
+// by Chu, Harwood and Stuckey).  The watches know if a watched clause is
+// binary, in which case it never has to be visited.  If a binary clause is
+// falsified we continue propagating.
+
+// Finally, for long clauses we save the position of the last watch
+// replacement in 'pos', which in turn reduces certain quadratic accumulated
+// propagation costs (2013 JAIR article by Ian Gent) at the expense of four
+// more bytes for each clause.
+
+bool Internal::propagate () {
+
+  if (level) require_mode (SEARCH);
+  assert (!unsat);
+
+  START (propagate);
+
+  // Updating statistics counter in the propagation loops is costly so we
+  // delay until propagation ran to completion.
+  //
+  int64_t before = propagated;
+
+  while (!conflict && propagated != trail.size ()) {
+
+    const int lit = -trail[propagated++];
+    LOG ("propagating %d", -lit);
+    Watches & ws = watches (lit);
+
+    const const_watch_iterator eow = ws.end ();
+    watch_iterator j = ws.begin ();
+    const_watch_iterator i = j;
+
+    while (i != eow) {
+
+      const Watch w = *j++ = *i++;
+      const signed char b = val (w.blit);
+
+      if (b > 0) continue;                // blocking literal satisfied
+
+      if (w.binary ()) {
+
+        // In principle we can ignore garbage binary clauses too, but that
+        // would require to dereference the clause pointer all the time with
+        //
+        // if (w.clause->garbage) { j--; continue; } // (*)
+        //
+        // This is too costly.  It is however necessary to produce correct
+        // proof traces if binary clauses are traced to be deleted ('d ...'
+        // line) immediately as soon they are marked as garbage.  Actually
+        // finding instances where this happens is pretty difficult (six
+        // parallel fuzzing jobs in parallel took an hour), but it does
+        // occur.  Our strategy to avoid generating incorrect proofs now is
+        // to delay tracing the deletion of binary clauses marked as garbage
+        // until they are really deleted from memory.  For large clauses
+        // this is not necessary since we have to access the clause anyhow.
+        //
+        // Thanks go to Mathias Fleury, who wanted me to explain why the
+        // line '(*)' above was in the code. Removing it actually really
+        // improved running times and thus I tried to find concrete
+        // instances where this happens (which I found), and then
+        // implemented the described fix.
+
+        // Binary clauses are treated separately since they do not require
+        // to access the clause at all (only during conflict analysis, and
+        // there also only to simplify the code).
+
+        if (b < 0) conflict = w.clause;          // but continue ...
+        else search_assign (w.blit, w.clause);
+
+      } else {
+
+        if (conflict) break; // Stop if there was a binary conflict already.
+
+        // The cache line with the clause data is forced to be loaded here
+        // and thus this first memory access below is the real hot-spot of
+        // the solver.  Note, that this check is positive very rarely and
+        // thus branch prediction should be almost perfect here.
+
+        if (w.clause->garbage) { j--; continue; }
+
+        literal_iterator lits = w.clause->begin ();
+
+        // Simplify code by forcing 'lit' to be the second literal in the
+        // clause.  This goes back to MiniSAT.  We use a branch-less version
+        // for conditionally swapping the first two literals, since it
+        // turned out to be substantially faster than this one
+        //
+        //  if (lits[0] == lit) swap (lits[0], lits[1]);
+        //
+        // which achieves the same effect, but needs a branch.
+        //
+        const int other = lits[0] ^ lits[1] ^ lit;
+        const signed char u = val (other); // value of the other watch
+
+        if (u > 0) j[-1].blit = other; // satisfied, just replace blit
+        else {
+
+          // This follows Ian Gent's (JAIR'13) idea of saving the position
+          // of the last watch replacement.  In essence it needs two copies
+          // of the default search for a watch replacement (in essence the
+          // code in the 'if (v < 0) { ... }' block below), one starting at
+          // the saved position until the end of the clause and then if that
+          // one failed to find a replacement another one starting at the
+          // first non-watched literal until the saved position.
+
+          const int size = w.clause->size;
+          const literal_iterator middle = lits + w.clause->pos;
+          const const_literal_iterator end = lits + size;
+          literal_iterator k = middle;
+
+          // Find replacement watch 'r' at position 'k' with value 'v'.
+
+          int r = 0;
+          signed char v = -1;
+
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+
+          if (v < 0) {  // need second search starting at the head?
+
+            k = lits + 2;
+            assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+
+          w.clause->pos = k - lits;  // always save position
+
+          assert (lits + 2 <= k), assert (k <= w.clause->end ());
+
+          if (v > 0) {
+
+            // Replacement satisfied, so just replace 'blit'.
+
+            j[-1].blit = r;
+
+          } else if (!v) {
+
+            // Found new unassigned replacement literal to be watched.
+
+            LOG (w.clause, "unwatch %d in", lit);
+
+            lits[0] = other;
+            lits[1] = r;
+            *k = lit;
+
+            watch_literal (r, lit, w.clause);
+
+            j--;  // Drop this watch from the watch list of 'lit'.
+
+          } else if (!u) {
+
+            assert (v < 0);
+
+            // The other watch is unassigned ('!u') and all other literals
+            // assigned to false (still 'v < 0'), thus we found a unit.
+            //
+            search_assign (other, w.clause);
+
+            // Similar code is in the implementation of the SAT'18 paper on
+            // chronological backtracking but in our experience, this code
+            // first does not really seem to be necessary for correctness,
+            // and further does not improve running time either.
+            //
+            if (opts.chrono > 1) {
+
+              const int other_level = var (other).level;
+
+              if (other_level > var (lit).level) {
+
+                // The assignment level of the new unit 'other' is larger
+                // than the assignment level of 'lit'.  Thus we should find
+                // another literal in the clause at that higher assignment
+                // level and watch that instead of 'lit'.
+
+                assert (size > 2);
+
+                int pos, s = 0;
+
+                for (pos = 2; pos < size; pos++)
+                  if (var (s = lits[pos]).level == other_level)
+                    break;
+
+                assert (s);
+                assert (pos < size);
+
+                LOG (w.clause, "unwatch %d in", lit);
+                lits[pos] = lit;
+                lits[0] = other;
+                lits[1] = s;
+                watch_literal (s, other, w.clause);
+
+                j--;  // Drop this watch from the watch list of 'lit'.
+              }
+            }
+          } else {
+
+            assert (u < 0);
+            assert (v < 0);
+
+            // The other watch is assigned false ('u < 0') and all other
+            // literals as well (still 'v < 0'), thus we found a conflict.
+
+            conflict = w.clause;
+            break;
+          }
+        }
+      }
+    }
+
+    if (j != i) {
+
+      while (i != eow)
+        *j++ = *i++;
+
+      ws.resize (j - ws.begin ());
+    }
+  }
+
+  if (searching_lucky_phases) {
+
+    if (conflict)
+      LOG (conflict, "ignoring lucky conflict");
+
+  } else {
+
+    // Avoid updating stats eagerly in the hot-spot of the solver.
+    //
+    stats.propagations.search += propagated - before;
+
+    if (!conflict) no_conflict_until = propagated;
+    else {
+
+      if (stable) stats.stabconflicts++;
+      stats.conflicts++;
+
+      LOG (conflict, "conflict");
+
+      // The trail before the current decision level was conflict free.
+      //
+      no_conflict_until = control[level].trail;
+    }
+  }
+
+  STOP (propagate);
+
+  return !conflict;
+}
+
+}
diff --git a/hCaD_V2/src/queue.cpp b/hCaD_V2/src/queue.cpp
new file mode 100644
index 0000000..ff167c8
--- /dev/null
+++ b/hCaD_V2/src/queue.cpp
@@ -0,0 +1,86 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Slightly different than 'bump_variable' since the variable is not
+// enqueued at all.
+
+inline void Internal::init_enqueue (int idx) {
+  Link & l = links[idx];
+  if (opts.reverse) {
+    l.prev = 0;
+    if (queue.first) {
+      assert (!links[queue.first].prev);
+      links[queue.first].prev = idx;
+      btab[idx] = btab[queue.first] - 1;
+    } else {
+      assert (!queue.last);
+      queue.last = idx;
+      btab[idx] = 0;
+    }
+    assert (btab[idx] <= stats.bumped);
+    l.next = queue.first;
+    queue.first = idx;
+    if (!queue.unassigned)
+      update_queue_unassigned (queue.last);
+  } else {
+    l.next = 0;
+    if (queue.last) {
+      assert (!links[queue.last].next);
+      links[queue.last].next = idx;
+    } else {
+      assert (!queue.first);
+      queue.first = idx;
+    }
+    btab[idx] = ++stats.bumped;
+    l.prev = queue.last;
+    queue.last = idx;
+    update_queue_unassigned (queue.last);
+  }
+}
+
+// Initialize VMTF queue from current 'old_max_var + 1' to 'new_max_var'.
+// This incorporates an initial variable order.  We currently simply assume
+// that variables with smaller index are more important.  This is the same
+// as in MiniSAT (implicitly) and also matches the 'scores' initialization.
+//
+void Internal::init_queue (int old_max_var, int new_max_var) {
+  LOG ("initializing VMTF queue from %d to %d",
+    old_max_var + 1, new_max_var);
+  assert (old_max_var < new_max_var);
+  assert (!level);
+  for (int idx = old_max_var; idx < new_max_var; idx++)
+    init_enqueue (idx + 1);
+}
+
+// Shuffle the VMTF queue.
+
+void Internal::shuffle_queue () {
+  if (!opts.shuffle) return;
+  if (!opts.shufflequeue) return;
+  stats.shuffled++;
+  LOG ("shuffling queue");
+  vector<int> shuffle;
+  if (opts.shufflerandom) {
+    for (int idx = max_var; idx; idx--)
+      shuffle.push_back (idx);
+    Random random (opts.seed);                  // global seed
+    random += stats.shuffled;                   // different every time
+    for (int i = 0; i <= max_var-2; i++) {
+      const int j = random.pick_int (i, max_var-1);
+      swap (shuffle[i], shuffle[j]);
+    }
+  } else {
+    for (int idx = queue.last; idx; idx = links[idx].prev)
+      shuffle.push_back (idx);
+  }
+  queue.first = queue.last = 0;
+  for (const int idx : shuffle)
+    queue.enqueue (links, idx);
+  int64_t bumped = queue.bumped;
+  for (int idx = queue.last; idx; idx = links[idx].prev)
+    btab[idx] = bumped--;
+  queue.unassigned = queue.last;
+}
+
+}
diff --git a/hCaD_V2/src/queue.hpp b/hCaD_V2/src/queue.hpp
new file mode 100644
index 0000000..94e0dcc
--- /dev/null
+++ b/hCaD_V2/src/queue.hpp
@@ -0,0 +1,53 @@
+#ifndef _queue_hpp_INCLUDED
+#define _queue_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+// Links for double linked decision queue.
+
+struct Link {
+
+  int prev, next;    // variable indices
+
+  // initialized explicitly in 'init_queue'
+};
+
+typedef vector<Link> Links;
+
+// Variable move to front (VMTF) decision queue ordered by 'bumped'.  See
+// our SAT'15 paper for an explanation on how this works.
+
+struct Queue {
+
+  // We use integers instead of variable pointers.  This is more compact and
+  // also avoids issues due to moving the variable table during 'resize'.
+
+  int first, last;    // anchors (head/tail) for doubly linked list
+  int unassigned;     // all variables after this one are assigned
+  int64_t bumped;     // see 'Internal.update_queue_unassigned'
+
+  Queue () : first (0), last (0), unassigned (0), bumped (0) { }
+
+  // We explicitly provide the mapping of integer indices to links to the
+  // following two (inlined) functions.  This avoids including
+  // 'internal.hpp' and breaks a cyclic dependency, so we can keep their
+  // code here in this header file.  Otherwise they are just ordinary doubly
+  // linked list 'dequeue' and 'enqueue' operations.
+
+  inline void dequeue (Links & links, int idx) {
+    Link & l = links[idx];
+    if (l.prev) links[l.prev].next = l.next; else first = l.next;
+    if (l.next) links[l.next].prev = l.prev; else last = l.prev;
+  }
+
+  inline void enqueue (Links & links, int idx) {
+    Link & l = links[idx];
+    if ((l.prev = last)) links[last].next = idx; else first = idx;
+    last = idx;
+    l.next = 0;
+  }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/radix.hpp b/hCaD_V2/src/radix.hpp
new file mode 100644
index 0000000..bd28f56
--- /dev/null
+++ b/hCaD_V2/src/radix.hpp
@@ -0,0 +1,167 @@
+#ifndef _radix_hpp_INCLUDED
+#define _radix_hpp_INCLUDED
+
+#include <cassert>
+#include <iterator>
+#include <cstring>
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// This provides an implementation of a generic radix sort algorithm. The
+// reason for having it is that for certain benchmarks and certain parts of
+// CaDiCaL where sorting is used, the standard sorting algorithm 'sort'
+// turned out to be a hot-spot. Up to 30% of the total running time was for
+// instance used for some benchmarks in sorting variables during bumping
+// to make sure to bump them in 'enqueued' order.
+//
+// Further, in most cases, where we need to sort something, sorting is
+// actually performed on positive numbers (such as the 'enqueued' time stamp
+// during bumping), which allows to use radix sort or variants. At least
+// starting with medium sized arrays to be sorted (say above 1000 elements,
+// but see discussion on 'MSORT' below), radix sort can be way faster.
+//
+// Finally it is stable, which is actually preferred most of the time too.
+//
+// This template algorithm 'rsort' takes as first template parameter the
+// iterator class similar to the standard 'sort' algorithm template, but
+// then as second parameter a function class (similar to the second 'less
+// than' parameter of 'sort') which can obtain a 'rank' from each element,
+// on which they are compared.  The 'rank' should be able to turn an element
+// into a number.  The type of these ranks is determined automatically but
+// should be 'unsigned'.
+
+struct pointer_rank {
+  typedef size_t Type;
+  Type operator () (void * ptr) { return (size_t) ptr; }
+};
+
+template<class I, class Rank> void rsort (I first, I last, Rank rank)
+{
+  typedef typename iterator_traits<I>::value_type T;
+  typedef typename Rank::Type R;
+
+  assert (first <= last);
+  const size_t n = last - first;
+  if (n <= 1) return;
+
+  const size_t l = 8;           // Radix 8, thus byte-wise.
+  const size_t w = (1<<l);      // So many buckets.
+
+  const unsigned mask = w - 1;  // Fast mod 'w'.
+
+// Uncomment the following define for large values of 'w' in order to keep
+// the large bucket array 'count' on the heap instead of the stack.
+//
+// #define CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+//
+#ifdef CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+  size_t * count = new size_t[w];       // Put buckets on the heap.
+#else
+  size_t count[w];                      // Put buckets on the stack.
+#endif
+
+  I a = first, b = last, c = a;
+  bool initialized = false;
+  vector<T> v;
+
+  R upper = 0, lower = ~upper;
+  R shifted = mask;
+  bool bounded = false;
+
+  R masked_lower = 0, masked_upper = mask;
+
+  for (size_t i = 0; i < 8 * sizeof (rank (*first)); i += l, shifted <<= l) {
+
+    if (bounded && (lower & shifted) == (upper & shifted))
+      continue;
+
+    memset (count + masked_lower, 0,
+            (masked_upper - masked_lower + 1) * sizeof *count);
+
+    const I end = c + n;
+
+    for (I p = c; p != end; p++) {
+      const auto r = rank (*p);
+      if (!bounded) lower &= r, upper |= r;
+      const auto s = r >> i;
+      const auto m = s & mask;
+      count[m]++;
+    }
+
+    masked_lower = (lower >> i) & mask;
+    masked_upper = (upper >> i) & mask;
+
+    if (!bounded)
+      {
+        bounded = true;
+        if ((lower & shifted) == (upper & shifted))
+          continue;
+      }
+
+    size_t pos = 0;
+    for (R j = masked_lower; j <= masked_upper; j++) {
+      const size_t delta = count[j];
+      count[j] = pos;
+      pos += delta;
+    }
+
+    if (!initialized) {
+      assert (&*c == &*a);      // MS VC++
+      v.resize (n);
+      b = v.begin ();
+      initialized = true;
+    }
+
+    I d = (&*c == &*a) ? b : a; // MS VC++
+
+    for (I p = c; p != end; p++) {
+      const auto r = rank (*p);
+      const auto s = r >> i;
+      const auto m = s & mask;
+      d[count[m]++] = *p;
+    }
+    c = d;
+  }
+
+  if (c == b) {
+    for (size_t i = 0; i < n; i++)
+      a[i] = b[i];
+  }
+
+#ifdef CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+  delete [] count;
+#endif
+
+#ifndef NDEBUG
+  for (I p = first; p + 1 != last; p++)
+    assert (rank (p[0]) <= rank (p[1]));
+#endif
+}
+
+// It turns out that for small number of elements (like '100') and in
+// particular for large value ranges the standard sorting function is
+// considerably faster than our radix sort (like 2.5x). This negative effect
+// vanishes at around 800 elements (sorting integers) and thus we provide a
+// function 'MSORT' which selects between standard sort and radix sort based
+// on the number of elements.  However we failed to put this into proper C++
+// style template code and thus have to use a macro instead.  We also do not
+// use it everywhere instead of 'rsort' since it requires a fourth
+// parameter, which is awkward, particular in those situation where we
+// expect large arrays to be sorted anyhow (such as during sorting the
+// clauses in an arena or the probes during probing).  The first argument
+// is the limit up to which we use the standard sort.  Above the limit we
+// use radix sort.  As usual we do not want to hard code it here (default
+// is '800') in order to make fuzzing and delta debugging more effective.
+
+#define MSORT(LIMIT,FIRST,LAST,RANK,LESS) \
+do { \
+  const size_t N = LAST - FIRST; \
+  if (N <= (size_t) (LIMIT)) sort (FIRST, LAST, LESS); \
+  else rsort (FIRST, LAST, RANK); \
+} while (0)
+
+}
+
+#endif
diff --git a/hCaD_V2/src/random.cpp b/hCaD_V2/src/random.cpp
new file mode 100644
index 0000000..a85703d
--- /dev/null
+++ b/hCaD_V2/src/random.cpp
@@ -0,0 +1,205 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// Our random number generator is seeded by default (i.e., in the default
+// constructor) with random seeds, which should be unique across machines,
+// processes and time.  This makes this code below rather operating system
+// dependent.  We also use in essence defensive programming, overlaying
+// several methods to get randomness since in the past we were bitten a
+// couple of times (and got the same seeds).  Having several methods makes
+// it also simpler to port randomly initializing seeds to different
+// operating systems (even though currently it is only tested on Linux).
+// This functionality is only used in the 'Mobical' model based tester at
+// this point, since the main solver explicitly sets a random seed ('0' by
+// default in 'options.hpp') and also currently only uses this seed in the
+// local search procedure explicitly without using the default constructor.
+// It is crucial for 'Mobical' to make sure that concurrent runs are really
+// independent.
+
+/*------------------------------------------------------------------------*/
+
+// Uncomment the following definition to force printing the computed hash
+// values for individual machine and process properties. This is only needed
+// for testing, porting and debugging different ports of this seeding and
+// hashing functions (uncomment and run 'mobical' for instance).
+
+/*
+#define DO_PRINT_HASH
+*/
+
+#ifdef DO_PRINT_HASH
+extern "C" {
+#include <inttypes.h>
+};
+#define PRINT_HASH(H) \
+do { \
+  printf ("c PRINT_HASH %32s () = %020" PRIu64 "\n", __func__, H); \
+  fflush (stdout); \
+} while (0)
+#else
+#define PRINT_HASH(...) do { } while (0)
+#endif
+
+/*------------------------------------------------------------------------*/
+
+// This is Linux specific but if '/var/lib/dbus/machine-id' does not exist
+// does not have any effect.  TODO: add a similar machine identity hashing
+// function for other operating systems (Windows and macOS).
+
+namespace CaDiCaL {
+
+static uint64_t hash_machine_identifier () {
+  FILE * file = fopen ("/var/lib/dbus/machine-id", "r");
+  uint64_t res = 0;
+  if (file) {
+    char buffer[128];
+    memset (buffer, 0, sizeof buffer);
+    size_t bytes = fread (buffer, 1, sizeof buffer - 1, file);
+    assert (bytes);
+    fclose (file);
+    if (bytes && bytes< sizeof buffer) {
+      buffer[bytes] = 0;
+      res = hash_string (buffer);
+    }
+  }
+  PRINT_HASH (res);
+  return res;
+}
+
+}
+
+/*------------------------------------------------------------------------*/
+
+// On our Linux cluster where we used an NFS mounted root disk the
+// 'machine-id' above (even on a locally mounted '/var' disk on each node)
+// was copied from '/etc/machine-id' which was shared among all nodes
+// (before figuring this out and fixing it). Thus the main idea of getting
+// different hash values through this machine identifier machines did not
+// work.  As an additional measure to increase the possibility to get
+// different seeds we are now also using network addresses (explicitly).
+
+#ifndef __WIN32
+
+extern "C" {
+#include <sys/socket.h>
+#include <netdb.h>
+#include <ifaddrs.h>
+#include <stdio.h>
+#include <stdlib.h>
+}
+
+#endif
+
+namespace CaDiCaL {
+
+static uint64_t hash_network_addresses () {
+  uint64_t res = 0;
+
+// We still need to properly port this to Windows, but since accessing the
+// IP address is only required for better randomization during testing
+// (running 'mobical' on a cluster for instance) it is not crucial unless
+// you really need to run 'mobical' on a Windows cluster where each node has
+// identical IP addresses.
+
+#ifndef __WIN32
+  struct ifaddrs * addrs;
+  if (!getifaddrs (&addrs)) {
+    for (struct ifaddrs * addr = addrs; addr; addr = addr->ifa_next) {
+      const int family = addr->ifa_addr->sa_family;
+      if (family == AF_INET || family == AF_INET6) {
+        const int size = (family == AF_INET) ?
+          sizeof (struct sockaddr_in) : sizeof (struct sockaddr_in6);
+        char buffer[128];
+        if (!getnameinfo (addr->ifa_addr, size, buffer, sizeof buffer,
+                          0, 0, NI_NUMERICHOST)) {
+          uint64_t tmp = hash_string (buffer);
+#ifdef DO_PRINT_HASH
+          printf ("c PRINT_HASH %35s = %020" PRIu64 "\n", buffer, tmp);
+          fflush (stdout);
+#endif
+          res ^= tmp;
+          res *= 10000000000000000051ul;
+        }
+      }
+    }
+    freeifaddrs (addrs);
+  }
+#endif
+
+  PRINT_HASH (res);
+  return res;
+}
+
+}
+
+/*------------------------------------------------------------------------*/
+
+// Hash the current wall-clock time in seconds.
+
+extern "C" {
+#include <time.h>
+}
+
+namespace CaDiCaL {
+
+static uint64_t hash_time () {
+  uint64_t res = ::time (0);
+  PRINT_HASH (res);
+  return res;
+}
+
+}
+
+/*------------------------------------------------------------------------*/
+
+// Hash the process identified.
+
+extern "C" {
+#include <sys/types.h>
+#include <unistd.h>
+}
+
+namespace CaDiCaL {
+
+static uint64_t hash_process () {
+  uint64_t res = getpid ();
+  PRINT_HASH (res);
+  return res;
+}
+
+}
+
+/*------------------------------------------------------------------------*/
+
+// Hash the current number of clock cycles.
+
+#include <ctime>
+
+namespace CaDiCaL {
+
+static uint64_t hash_clock_cycles () {
+  uint64_t res = std::clock ();
+  PRINT_HASH (res);
+  return res;
+}
+
+}
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+Random::Random () : state (1) {
+  add (hash_machine_identifier ());
+  add (hash_network_addresses ());
+  add (hash_clock_cycles ());
+  add (hash_process ());
+  add (hash_time ());
+#ifdef DO_PRINT_HASH
+  printf ("c PRINT_HASH %32s    = %020" PRIu64 "\n", "combined", state);
+  fflush (stdout);
+#endif
+}
+
+}
diff --git a/hCaD_V2/src/random.hpp b/hCaD_V2/src/random.hpp
new file mode 100644
index 0000000..290dbf4
--- /dev/null
+++ b/hCaD_V2/src/random.hpp
@@ -0,0 +1,87 @@
+/*------------------------------------------------------------------------*/
+
+// Random number generator.
+
+namespace CaDiCaL {
+
+class Random {
+
+  uint64_t state;
+
+  void add (uint64_t a) {
+    if (!(state += a)) state = 1;
+    next ();
+  }
+
+public:
+
+  // Without argument use a machine, process and time dependent seed.
+  //
+  Random ();
+
+  Random (uint64_t seed) : state (seed) { }
+  void operator= (uint64_t seed) { state = seed; }
+  Random (const Random & other) : state (other.seed ()) { }
+
+  void operator += (uint64_t a) { add (a); }
+  uint64_t seed () const { return state; }
+
+  uint64_t next () {
+    state *= 6364136223846793005ul;
+    state += 1442695040888963407ul;
+    assert (state);
+    return state;
+  }
+
+  uint32_t generate () { next (); return state >> 32; }
+  int      generate_int () { return (int) generate (); }
+  bool     generate_bool () { return generate () < 2147483648u; }
+
+  // Generate 'double' value in the range '[0,1]'.
+  //
+  double generate_double () { return generate () / 4294967295.0; }
+
+  // Generate 'int' value in the range '[l,r]'.
+  //
+  int pick_int (int l, int r) {
+    assert (l <= r);
+    const unsigned delta = 1 + r - (unsigned) l;
+    unsigned tmp = generate (), scaled;
+    if (delta) {
+      const double fraction = tmp / 4294967296.0;
+      scaled = delta * fraction;
+    } else scaled = tmp;
+    const int res = scaled + l;
+    assert (l <= res);
+    assert (res <= r);
+    return res;
+  }
+
+  int pick_log (int l, int r) {
+    assert (l <= r);
+    const unsigned delta = 1 + r - (unsigned) l;
+    int log_delta = delta ? 0 : 32;
+    while (log_delta < 32 && (1u << log_delta) < delta)
+      log_delta++;
+    const int log_res = pick_int (0, log_delta);
+    unsigned tmp = generate ();
+    if (log_res < 32) tmp &= (1u << log_res) - 1;
+    if (delta) tmp %= delta;
+    const int res = l + tmp;
+    assert (l <= res), assert (res <= r);
+    return res;
+  }
+
+  // Generate 'double' value in the range '[l,r]'.
+  //
+  double pick_double (double l, double r) {
+    assert (l <= r);
+    double res = (r - l) * generate_double ();
+    res += l;
+    assert (l <= res);
+    assert (res <= r);
+    return res;
+  }
+};
+
+}
diff --git a/hCaD_V2/src/range.hpp b/hCaD_V2/src/range.hpp
new file mode 100644
index 0000000..9c1fc2a
--- /dev/null
+++ b/hCaD_V2/src/range.hpp
@@ -0,0 +1,93 @@
+#ifndef _range_hpp_INCLUDED
+#define _range_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Clause;
+
+/*----------------------------------------------------------------------*/
+
+// Used for compact and safe iteration over positive ranges of integers,
+// particularly for iterating over all variable indices.
+//
+//   Range vars (max_var);
+//   for (auto idx : vars) ...
+//
+// This iterates over '1, ..., max_var' and is safe for non-negative
+// numbers, thus also for 'max_var == 0' or 'max_var == INT_MAX'.
+//
+// Note that
+//
+//   for (int idx = 1; idx <= max_var; idx++) ...
+//
+// leads to an overflow if 'max_var == INT_MAX' and thus depending on what
+// the compiler does ('int' overflow is undefined) might lead to any
+// behaviour (infinite loop or worse array access way out of bounds).
+//
+// If we make 'idx' in this last 'for' loop an 'unsigned' then it is safe to
+// use this idiom, but we would need to cast 'max_var' explicitly to 'int'
+// in order to avoid a warning in the loop condition and actually everywhere
+// where 'idx' is compared to a 'signed' expression.  Worse for instance
+// 'vals[-idx]' will lead to out of bounds access too.  This is awkward and
+// using the range iterator provided here is safer in general.
+//
+// Another issue is that the dereferencing operator '*' below is required to
+// return a reference to the internal index of the iterator.  Thus the 'idx'
+// in the auto loop is actually of the same type as the internal state of
+// the iterator.  To keep it 'signed' and still avoid overflow issues we
+// just have to make sure to use the proper increment (with two implicit
+// casts, i.e., from 'int' to 'unsigned', then 'unsigned' addition and the
+// result is cast back from 'unsigned' to 'int').
+//
+// For simplicity we keep a reference to the actual maximum integer, e.g.,
+// 'max_var', which makes the idiom 'for (auto idx : vars) ...' possible.
+// Further note that the referenced integer has to be non-negative before
+// starting to iterate (it can be zero though), otherwise it breaks.
+
+class Range {
+  static unsigned inc (unsigned u) { return u + 1u; }
+  class iterator {
+    int idx;
+  public:
+    iterator (int i) : idx (i) { }
+    void operator++ () { idx = inc (idx); }
+    const int & operator* () const { return idx; }
+    friend bool operator != (const iterator & a, const iterator & b) {
+      return a.idx != b.idx;
+    }
+  };
+  int & n;
+public:
+  iterator begin () const { return assert (n >= 0), iterator (inc (0)); }
+  iterator end ()   const { return assert (n >= 0), iterator (inc (n)); }
+  Range (int & m) : n (m) { assert (m >= 0); }
+};
+
+// Same, but iterating over literals '-1,1,-2,2,....,-max_var,max_var'.
+//
+// The only difference to 'Range' is the 'inc' function, but I am too lazy
+// to figure out how to properly factor the code into a generic range
+// template with 'inc' as only parameter.  This gives at least clean code.
+
+class Sange {
+  static unsigned inc (unsigned u) { return ~u + (u >> 31); }
+  class iterator {
+    int lit;
+  public:
+    iterator (int i) : lit (i) { }
+    void operator++ () { lit = inc (lit); }
+    const int & operator* () const { return lit; }
+    friend bool operator != (const iterator & a, const iterator & b) {
+      return a.lit != b.lit;
+    }
+  };
+  int & n;
+public:
+  iterator begin () const { return assert (n >= 0), iterator (inc (0)); }
+  iterator end ()   const { return assert (n >= 0), iterator (inc (n)); }
+  Sange (int & m) : n (m) { assert (m >= 0); }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/reap.cpp b/hCaD_V2/src/reap.cpp
new file mode 100644
index 0000000..93a26b8
--- /dev/null
+++ b/hCaD_V2/src/reap.cpp
@@ -0,0 +1,130 @@
+#include "reap.hpp"
+#include<cstring>
+#include<cassert>
+#include <climits>
+
+void Reap::init() {
+  for(auto & bucket : buckets)
+    bucket = {0};
+  assert(!num_elements);
+  assert(!last_deleted);
+  min_bucket = 32;
+  assert(!max_bucket);
+}
+
+void Reap::release() {
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
+
+Reap::Reap () {
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
+
+
+static inline unsigned leading_zeroes_of_unsigned(unsigned x) {
+  return x ? __builtin_clz(x) : sizeof(unsigned) * 8;
+}
+
+void Reap::push(unsigned e)
+{
+  assert(last_deleted <= e);
+  const unsigned diff = e ^ last_deleted;
+  const unsigned bucket = 32 - leading_zeroes_of_unsigned(diff);
+  buckets[bucket].push_back(e);
+  if (min_bucket > bucket)
+    min_bucket = bucket;
+  if (max_bucket < bucket)
+    max_bucket = bucket;
+  assert(num_elements != UINT_MAX);
+  num_elements++;
+}
+
+unsigned Reap::pop() {
+  assert(num_elements > 0);
+  unsigned i = min_bucket;
+  for (;;) {
+    assert(i < 33);
+    assert(i <= max_bucket);
+    std::vector<unsigned> &s = buckets[i];
+    if (s.empty()) {
+      min_bucket = ++i;
+      continue;
+    }
+    unsigned res;
+    if (i) {
+      res = UINT_MAX;
+      const auto begin = std::begin(s);
+      const auto end = std::end(s);
+      auto q = std::begin(s);
+      assert(begin < end);
+      for (auto p = begin; p != end; ++p) {
+        const unsigned tmp = *p;
+        if (tmp >= res)
+          continue;
+        res = tmp;
+        q = p;
+      }
+
+      for (auto p = begin; p != end; ++p) {
+        if (p == q)
+          continue;
+        const unsigned other = *p;
+        const unsigned diff = other ^ res;
+        assert(sizeof(unsigned) == 4);
+        const unsigned j = 32 - leading_zeroes_of_unsigned(diff);
+        assert(j < i);
+        buckets[j].push_back(other);
+        if (min_bucket > j)
+          min_bucket = j;
+      }
+
+      s.clear();
+
+      if (i && max_bucket == i) {
+#ifndef NDEBUG
+        for (unsigned j = i + 1; j < 33; j++)
+          assert(buckets[j].empty());
+#endif
+        if (s.empty())
+          max_bucket = i - 1;
+      }
+    } else {
+      res = last_deleted;
+      assert(!buckets[0].empty());
+      assert(buckets[0].at(0) == res);
+      buckets[0].pop_back();
+    }
+
+    if (min_bucket == i) {
+#ifndef NDEBUG
+      for (unsigned j = 0; j < i; j++)
+        assert(buckets[j].empty());
+#endif
+      if (s.empty())
+        min_bucket = std::min((int)(i + 1), 32);
+    }
+
+    --num_elements;
+    assert(last_deleted <= res);
+    last_deleted = res;
+
+    return res;
+  }
+}
+
+void Reap::clear()
+{
+  assert(max_bucket <= 32);
+  for (unsigned i = 0; i < 33; i++)
+    buckets[i].clear();
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
diff --git a/hCaD_V2/src/reap.hpp b/hCaD_V2/src/reap.hpp
new file mode 100644
index 0000000..3ad4875
--- /dev/null
+++ b/hCaD_V2/src/reap.hpp
@@ -0,0 +1,31 @@
+#ifndef _reap_h_INCLUDED
+#define _reap_h_INCLUDED
+
+#include <vector>
+#include <cstddef>
+
+class Reap {
+public:
+  Reap();
+  void init();
+  void release();
+  inline bool empty() {
+    return !num_elements;
+  }
+
+  inline size_t size() {
+    return num_elements;
+  }
+
+  void push(unsigned);
+  void clear();
+  unsigned pop();
+private:
+  size_t num_elements;
+  unsigned last_deleted;
+  unsigned min_bucket;
+  unsigned max_bucket;
+  std::vector<unsigned> buckets[33];
+};
+
+#endif
diff --git a/hCaD_V2/src/reduce.cpp b/hCaD_V2/src/reduce.cpp
new file mode 100644
index 0000000..c7efffe
--- /dev/null
+++ b/hCaD_V2/src/reduce.cpp
@@ -0,0 +1,212 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Once in a while we reduce, e.g., we remove learned clauses which are
+// supposed to be less useful in the future.  This is done in increasing
+// intervals, which has the effect of allowing more and more learned clause
+// to be kept for a longer period.  The number of learned clauses kept
+// in memory corresponds to an upper bound on the 'space' of a resolution
+// proof needed to refute a formula in proof complexity sense.
+
+bool Internal::reducing () {
+  if (!opts.reduce) return false;
+  if (!stats.current.redundant) return false;
+  return stats.conflicts >= lim.reduce;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Even less regularly we are flushing all redundant clauses.
+
+bool Internal::flushing () {
+  if (!opts.flush) return false;
+  return stats.conflicts >= lim.flush;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::mark_clauses_to_be_flushed () {
+  for (const auto & c : clauses) {
+    if (!c->redundant) continue; // keep irredundant
+    if (c->garbage) continue;    // already marked as garbage
+    if (c->reason) continue;     // need to keep reasons
+    const unsigned used = c->used;
+    if (used) c->used--;
+    if (used) continue;          // but keep recently used clauses
+    mark_garbage (c);            // flush unused clauses
+    if (c->hyper) stats.flush.hyper++;
+    else stats.flush.learned++;
+  }
+  // No change to 'lim.kept{size,glue}'.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Clauses of larger glue or larger size are considered less useful.
+//
+// We also follow the observations made by the Glucose team in their
+// IJCAI'09 paper and keep all low glue clauses limited by
+// 'options.keepglue' (typically '2').
+//
+// In earlier versions we pre-computed a 64-bit sort key per clause and
+// wrapped a pointer to the clause and the 64-bit sort key into a separate
+// data structure for sorting.  This was probably faster but awkward and
+// so we moved back to a simpler scheme which also uses 'stable_sort'
+// instead of 'rsort' below.  Sorting here is not a hot-spot anyhow.
+
+struct reduce_less_useful {
+  bool operator () (const Clause * c, const Clause * d) const {
+    if (c->glue > d->glue) return true;
+    if (c->glue < d->glue) return false;
+    return c->size > d->size;
+  }
+};
+
+// This function implements the important reduction policy. It determines
+// which redundant clauses are considered not useful and thus will be
+// collected in a subsequent garbage collection phase.
+
+void Internal::mark_useless_redundant_clauses_as_garbage () {
+
+  // We use a separate stack for sorting candidates for removal.  This uses
+  // (slightly) more memory but has the advantage to keep the relative order
+  // in 'clauses' intact, which actually due to using stable sorting goes
+  // into the candidate selection (more recently learned clauses are kept if
+  // they otherwise have the same glue and size).
+
+  vector<Clause *> stack;
+
+  stack.reserve (stats.current.redundant);
+
+  for (const auto & c : clauses) {
+    if (!c->redundant) continue;    // Keep irredundant.
+    if (c->garbage) continue;       // Skip already marked.
+    if (c->reason) continue;        // Need to keep reasons.
+    const unsigned used = c->used;
+    if (used) c->used--;
+    if (c->hyper) {                 // Hyper binary and ternary resolvents
+      assert (c->size <= 3);        // are only kept for one reduce round
+      if (!used) mark_garbage (c);  // (even if 'c->keep' is true) unless
+      continue;                     //  used recently.
+    }
+    if (used) continue;             // Do keep recently used clauses.
+    if (c->keep) continue;          // Forced to keep (see above).
+
+    stack.push_back (c);
+  }
+
+  stable_sort (stack.begin (), stack.end (), reduce_less_useful ());
+
+  size_t target = 1e-2 * opts.reducetarget * stack.size ();
+
+  // This is defensive code, which I usually consider a bug, but here I am
+  // just not sure that using floating points in the line above is precise
+  // in all situations and instead of figuring that out, I just use this.
+  //
+  if (target > stack.size ()) target = stack.size ();
+
+  PHASE ("reduce", stats.reductions, "reducing %zd clauses %.0f%%",
+    target, percent (target, stats.current.redundant));
+
+  auto i = stack.begin ();
+  const auto t = i + target;
+  while (i != t) {
+    Clause * c = *i++;
+    LOG (c, "marking useless to be collected");
+    mark_garbage (c);
+    stats.reduced++;
+  }
+
+  lim.keptsize = lim.keptglue = 0;
+
+  const auto end = stack.end ();
+  for (i = t; i != end; i++) {
+    Clause * c = *i;
+    LOG (c, "keeping");
+    if (c->size > lim.keptsize) lim.keptsize = c->size;
+    if (c->glue > lim.keptglue) lim.keptglue = c->glue;
+  }
+
+  erase_vector (stack);
+
+  PHASE ("reduce", stats.reductions,
+    "maximum kept size %d glue %d", lim.keptsize, lim.keptglue);
+}
+
+/*------------------------------------------------------------------------*/
+
+// If chronological backtracking produces out-of-order assigned units, then
+// it is necessary to completely propagate them at the root level in order
+// to derive all implied units.  Otherwise the blocking literals in
+// 'flush_watches' are messed up and assertion 'FW1' fails.
+
+bool Internal::propagate_out_of_order_units () {
+  if (!level) return true;
+  int oou = 0;
+  for (size_t i = control[1].trail; !oou && i < trail.size (); i++) {
+    const int lit = trail[i];
+    assert (val (lit) > 0);
+    if (var (lit).level) continue;
+    LOG ("found out-of-order assigned unit %d", oou);
+    oou = lit;
+  }
+  if (!oou) return true;
+  assert (opts.chrono);
+  backtrack (0);
+  if (propagate ()) return true;
+  learn_empty_clause ();
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::reduce () {
+  START (reduce);
+
+  stats.reductions++;
+  report ('.', 1);
+
+  bool flush = flushing ();
+  if (flush) stats.flush.count++;
+
+  if (!propagate_out_of_order_units ()) goto DONE;
+
+  mark_satisfied_clauses_as_garbage ();
+  protect_reasons ();
+  if (flush) mark_clauses_to_be_flushed ();
+  else mark_useless_redundant_clauses_as_garbage ();
+  garbage_collection ();
+
+  {
+    int64_t delta = opts.reduceint * (stats.reductions + 1);
+    if (irredundant () > 1e5) {
+      delta *= log (irredundant ()/1e4) / log (10);
+      if (delta < 1) delta = 1;
+    }
+    lim.reduce = stats.conflicts + delta;
+    PHASE ("reduce", stats.reductions,
+      "new reduce limit %" PRId64 " after %" PRId64 " conflicts",
+      lim.reduce, delta);
+  }
+
+  if (flush) {
+    PHASE ("flush", stats.flush.count,
+      "new flush increment %" PRId64 "", inc.flush);
+    inc.flush *= opts.flushfactor;
+    lim.flush = stats.conflicts + inc.flush;
+    PHASE ("flush", stats.flush.count,
+      "new flush limit %" PRId64 "", lim.flush);
+  }
+
+  last.reduce.conflicts = stats.conflicts;
+
+DONE:
+
+  report (flush ? 'f' : '-');
+  STOP (reduce);
+}
+
+}
diff --git a/hCaD_V2/src/reluctant.hpp b/hCaD_V2/src/reluctant.hpp
new file mode 100644
index 0000000..fb62d67
--- /dev/null
+++ b/hCaD_V2/src/reluctant.hpp
@@ -0,0 +1,70 @@
+#ifndef _reluctant_hpp_INCLUDED
+#define _reluctant_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+// This is Donald Knuth's version of the Luby restart sequence which he
+// called 'reluctant doubling'.  His bit-twiddling formulation in line (DK)
+// requires to keep two words around which are updated every time the
+// reluctant doubling sequence is advanced.  The original version in the
+// literature uses a complex recursive function which computes the length of
+// the next inactive sub-sequence every time (but is state-less).
+//
+// In our code we incorporate a base interval 'period' and only after period
+// many calls to 'tick' times the current sequence value we update the
+// reluctant doubling sequence value.  The 'tick' call is decoupled from
+// the activation signal of the sequence (the 'bool ()' operator) through
+// 'trigger'.  It is also possible to set an upper limit to the length of an
+// inactive sub-sequence.  If that limit is reached the whole reluctant
+// doubling sequence starts over with the initial values.
+
+class Reluctant {
+
+  uint64_t u, v, limit;
+  uint64_t period, countdown;
+  bool trigger, limited;
+
+public:
+
+  Reluctant () : period (0), trigger (false) { }
+
+  void enable (int p, int64_t l) {
+    assert (p > 0);
+    u = v = 1;
+    period = countdown = p;
+    trigger = false;
+    if (l <= 0) limited = false;
+    else limited = true, limit = l;
+  };
+
+  void disable () { period = 0, trigger = false; }
+
+  // Increments the count until the 'period' is hit.  Then it performs the
+  // actual increment of reluctant doubling.  This gives the common 'Luby'
+  // sequence with the specified base interval period.  As soon the limit is
+  // reached (countdown goes to zero) we remember this event and then
+  // disable updating the reluctant sequence until the signal is delivered.
+
+  void tick () {
+
+    if (!period) return;        // disabled
+    if (trigger) return;        // already triggered
+    if (--countdown) return;    // not there yet
+
+    if ((u & -u) == v) u = u + 1, v = 1; else v = 2*v; // (DK)
+
+    if (limited && v >= limit) u = v = 1;
+    countdown = v * period;
+    trigger = true;
+  }
+
+  operator bool () {
+    if (!trigger) return false;
+    trigger = false;
+    return true;
+  }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/rephase.cpp b/hCaD_V2/src/rephase.cpp
new file mode 100644
index 0000000..6951144
--- /dev/null
+++ b/hCaD_V2/src/rephase.cpp
@@ -0,0 +1,229 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// We experimented with resetting and reinitializing the saved phase with
+// many solvers. Actually RSAT had already such a scheme.  Our newest
+// version seems to be quite beneficial for satisfiable instances.  In an
+// arithmetic increasing interval in the number of conflicts we either use
+// the original phase (set by the option 'phase'), its inverted value, flip
+// the current phase, pick random phases, then pick the best since the last
+// time a best phase was picked and finally also use local search to find
+// phases which minimize the number of falsified clauses.  During
+// stabilization (see 'stabilizing' in 'restart.cpp' when 'stable' is true)
+// we execute a different rephasing schedule.  The same applies if local
+// search is disabled.
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::rephasing () {
+  if (!opts.rephase) return false;
+  if (opts.forcephase) return false;
+  return stats.conflicts > lim.rephase;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Pick the original default phase.
+
+char Internal::rephase_original () {
+  stats.rephased.original++;
+  signed char val = opts.phase ? 1 : -1;        // original = initial
+  PHASE ("rephase", stats.rephased.total,
+    "switching to original phase %d", val);
+  for (auto idx : vars)
+    phases.saved[idx] = val;
+  return 'O';
+}
+
+// Pick the inverted original default phase.
+
+char Internal::rephase_inverted () {
+  stats.rephased.inverted++;
+  signed char val = opts.phase ? -1 : 1;        // original = -initial
+  PHASE ("rephase", stats.rephased.total,
+    "switching to inverted original phase %d", val);
+  for (auto idx : vars)
+    phases.saved[idx] = val;
+  return 'I';
+}
+
+// Flip the current phase.
+
+char Internal::rephase_flipping () {
+  stats.rephased.flipped++;
+  PHASE ("rephase", stats.rephased.total,
+    "flipping all phases individually");
+  for (auto idx : vars)
+    phases.saved[idx] *= -1;
+  return 'F';
+}
+
+// Complete random picking of phases.
+
+char Internal::rephase_random () {
+  stats.rephased.random++;
+  PHASE ("rephase", stats.rephased.total,
+    "resetting all phases randomly");
+  Random random (opts.seed);                    // global seed
+  random += stats.rephased.random;              // different every time
+  for (auto idx : vars)
+    phases.saved[idx] = random.generate_bool () ? -1 : 1;
+  return '#';
+}
+
+// Best phases are those saved at the largest trail height without conflict.
+// See code and comments in 'update_target_and_best' in 'backtrack.cpp'
+
+char Internal::rephase_best () {
+  stats.rephased.best++;
+  PHASE ("rephase", stats.rephased.total,
+    "overwriting saved phases by best phases");
+  signed char val;
+  for (auto idx : vars)
+    if ((val = phases.best[idx]))
+      phases.saved[idx] = val;
+  return 'B';
+}
+
+// Trigger local search 'walk' in 'walk.cpp'.
+
+char Internal::rephase_walk () {
+  stats.rephased.walk++;
+  PHASE ("rephase", stats.rephased.total,
+    "starting local search to improve current phase");
+  walk ();
+  return 'W';
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::rephase () {
+
+  stats.rephased.total++;
+  PHASE ("rephase", stats.rephased.total,
+    "reached rephase limit %" PRId64 " after %" PRId64 " conflicts",
+    lim.rephase, stats.conflicts);
+
+  // Report current 'target' and 'best' and then set 'rephased' below, which
+  // will trigger reporting the new 'target' and 'best' after updating it in
+  // the next 'update_target_and_best' called from the next 'backtrack'.
+  //
+  report ('~', 1);
+
+  backtrack ();
+  clear_phases (phases.target);
+  target_assigned = 0;
+
+  size_t count = lim.rephased[stable]++;
+  bool single;
+  char type;
+
+  if (opts.stabilize && opts.stabilizeonly) single = true;
+  else single = !opts.stabilize;
+
+  if (single && !opts.walk) {
+    // (inverted,best,flipping,best,random,best,original,best)^\omega
+    switch (count % 8) {
+      case 0:  type = rephase_inverted (); break;
+      case 1:  type = rephase_best ();     break;
+      case 2:  type = rephase_flipping (); break;
+      case 3:  type = rephase_best ();     break;
+      case 4:  type = rephase_random ();   break;
+      case 5:  type = rephase_best ();     break;
+      case 6:  type = rephase_original (); break;
+      case 7:  type = rephase_best ();     break;
+      default: type = 0;                   break;
+    }
+  } else if (single && opts.walk) {
+    // (inverted,best,walk,
+    //  flipping,best,walk,
+    //    random,best,walk,
+    //  original,best,walk)^\omega
+    switch (count % 12) {
+      case 0:  type = rephase_inverted (); break;
+      case 1:  type = rephase_best ();     break;
+      case 2:  type = rephase_walk ();     break;
+      case 3:  type = rephase_flipping (); break;
+      case 4:  type = rephase_best ();     break;
+      case 5:  type = rephase_walk ();     break;
+      case 6:  type = rephase_random ();   break;
+      case 7:  type = rephase_best ();     break;
+      case 8:  type = rephase_walk ();     break;
+      case 9:  type = rephase_original (); break;
+      case 10: type = rephase_best ();     break;
+      case 11: type = rephase_walk ();     break;
+      default: type = 0;                   break;
+    }
+  } else if (stable && !opts.walk) {
+    // original,inverted,(best,original,best,inverted)^\omega
+    if (!count) type = rephase_original ();
+    else if (count == 1) type = rephase_inverted ();
+    else switch ((count-2) % 4) {
+      case 0:  type = rephase_best ();     break;
+      case 1:  type = rephase_original (); break;
+      case 2:  type = rephase_best ();     break;
+      case 3:  type = rephase_inverted (); break;
+      default: type = 0;                   break;
+    }
+  } else if (stable && opts.walk) {
+    // original,inverted,(best,walk,original,best,walk,inverted)^\omega
+    if (!count) type = rephase_original ();
+    else if (count == 1) type = rephase_inverted ();
+    else switch ((count-2) % 6) {
+      case 0:  type = rephase_best ();     break;
+      case 1:  type = rephase_walk ();     break;
+      case 2:  type = rephase_original (); break;
+      case 3:  type = rephase_best ();     break;
+      case 4:  type = rephase_walk ();     break;
+      case 5:  type = rephase_inverted (); break;
+      default: type = 0;                   break;
+    }
+  } else if (!stable && (!opts.walk || !opts.walknonstable)) {
+    // flipping,(random,best,flipping,best)^\omega
+    if (!count) type = rephase_flipping ();
+    else switch ((count-1) % 4) {
+      case 0:  type = rephase_random ();   break;
+      case 1:  type = rephase_best ();     break;
+      case 2:  type = rephase_flipping (); break;
+      case 3:  type = rephase_best ();     break;
+      default: type = 0;                   break;
+    }
+  } else {
+    assert (!stable && opts.walk && opts.walknonstable);
+    // flipping,(random,best,walk,flipping,best,walk)^\omega
+    if (!count) type = rephase_flipping ();
+    else switch ((count-1) % 6) {
+      case 0:  type = rephase_random ();   break;
+      case 1:  type = rephase_best ();     break;
+      case 2:  type = rephase_walk ();     break;
+      case 3:  type = rephase_flipping (); break;
+      case 4:  type = rephase_best ();     break;
+      case 5:  type = rephase_walk ();     break;
+      default: type = 0;                   break;
+    }
+  }
+  assert (type);
+
+  int64_t delta = opts.rephaseint * (stats.rephased.total + 1);
+  lim.rephase = stats.conflicts + delta;
+
+  PHASE ("rephase", stats.rephased.total,
+    "new rephase limit %" PRId64 " after %" PRId64 " conflicts",
+    lim.rephase, delta);
+
+  // This will trigger to report the effect of this new set of phases at the
+  // 'backtrack' (actually 'update_target_and_best') after the next
+  // conflict, as well as resetting 'best_assigned' then to allow to compute
+  // a new "best" assignment at that point.
+  //
+  last.rephase.conflicts = stats.conflicts;
+  rephased = type;
+
+  if (stable) shuffle_scores ();
+  else shuffle_queue ();
+}
+
+}
diff --git a/hCaD_V2/src/report.cpp b/hCaD_V2/src/report.cpp
new file mode 100644
index 0000000..31e23ea
--- /dev/null
+++ b/hCaD_V2/src/report.cpp
@@ -0,0 +1,248 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+#ifndef QUIET
+
+/*------------------------------------------------------------------------*/
+
+// Provide nicely formatted progress report messages while running through
+// the 'report' function below.  The code is so complex, because it should
+// be easy to add and remove reporting of certain statistics, while still
+// providing a nicely looking format with automatically aligned headers.
+
+/*------------------------------------------------------------------------*\
+
+The 'reports' are shown as 'c <char> ...' with '<char>' as follows:
+
+i  propagated learned unit clause
+O  backtracked after phases reset to original phase
+F  backtracked after flipping phases
+#  backtracked after randomly setting phases
+B  backtracked after resetting to best phases
+W  backtracked after local search improved phases
+b  blocked clause elimination
+G  before garbage collection
+C  after garbage collection
+/  compacted internal literals and remapped external to internal
+c  covered clause elimination
+d  decomposed binary implication graph and substituted equivalent literals
+2  removed duplicated binary clauses
+e  bounded variable elimination round
+^  variable elimination bound increased
+I  variable instantiation
+[  start of stable search phase
+]  end of stable search phase
+{  start of unstable search phase
+}  end of unstable search phase
+P  preprocessing round (capital 'P')
+L  local search round
+*  start of solving without the need to restore clauses
++  start of solving before restoring clauses
+r  start of solving after restoring clauses
+1  end of solving returns satisfiable
+0  end of solving returns unsatisfiable
+?  end of solving due to interrupt
+l  lucky phase solving
+p  failed literal probing round (lower case 'p')
+.  before reducing redundant clauses
+f  flushed redundant clauses
+-  reduced redundant clauses
+~  start of resetting phases
+R  restart
+s  subsumed clause removal round
+3  ternary resolution round
+t  transition reduction of binary implication graph
+w  vivified redundant and irredundant clauses
+v  vivified irredundant clauses
+
+The order of the list follows the occurrences of 'report' in the source
+files, i.e., obtained from "grep 'report (' *.cpp".   Note that some of the
+reports are only printed for higher verbosity level (for instance 'R').
+
+\*------------------------------------------------------------------------*/
+
+struct Report {
+
+  const char * header;
+  char buffer[20];
+  int pos;
+
+  Report (const char * h, int precision, int min, double value);
+  Report () { }
+
+  void print_header (char * line);
+};
+
+/*------------------------------------------------------------------------*/
+
+void Report::print_header (char * line) {
+  int len = strlen (header);
+  for (int i = -1, j = pos - (len + 1)/2 - 3; i < len; i++, j++)
+    line[j] = i < 0 ? ' ' : header[i];
+}
+
+Report::Report (const char * h, int precision, int min, double value)
+:
+  header (h)
+{
+  char fmt[32];
+  if (precision < 0) sprintf (fmt, "%%.%df", -precision - 1);
+  else sprintf (fmt, "%%.%df", precision);
+  sprintf (buffer, fmt, value);
+  const int width = strlen (buffer);
+  if (precision < 0) strcat (buffer, "%");
+  if (width >= min) return;
+  if (precision < 0) sprintf (fmt, "%%%d.%df%%%%", min, -precision - 1);
+  else sprintf (fmt, "%%%d.%df", min, precision);
+  sprintf (buffer, fmt, value);
+}
+
+/*------------------------------------------------------------------------*/
+
+// The following statistics are printed in columns, whenever 'report' is
+// called.  For instance 'reduce' with prefix '-' will call it.  The other
+// more interesting report is due to learning a unit, called iteration, with
+// prefix 'i'.  To add another statistics column, add a corresponding line
+// here.  If you want to report something else add 'report (..)' functions.
+
+#define TIME \
+  opts.reportsolve ? solve_time () : time ()
+
+#define MB \
+  (current_resident_set_size () / (double)(1l<<20))
+
+#define REMAINING \
+  (percent (active (), external->max_var))
+
+#define TRAIL \
+  (percent (averages.current.trail.slow, max_var))
+
+#define TARGET \
+  (percent (target_assigned, max_var))
+
+#define BEST \
+  (percent (best_assigned, max_var))
+
+#define REPORTS \
+/*     HEADER, PRECISION, MIN, VALUE */ \
+REPORT("seconds",      2, 5, TIME) \
+REPORT("MB",           0, 2, MB) \
+REPORT("level",        0, 2, averages.current.level) \
+REPORT("reductions",   0, 1, stats.reductions) \
+REPORT("restarts",     0, 3, stats.restarts) \
+REPORT("conflicts",    0, 4, stats.conflicts) \
+REPORT("redundant",    0, 4, stats.current.redundant) \
+REPORT("trail",       -1, 2, TRAIL) \
+REPORT("glue",         0, 1, averages.current.glue.slow) \
+REPORT("irredundant",  0, 4, stats.current.irredundant) \
+REPORT("variables",    0, 3, active ()) \
+REPORT("remaining",   -1, 2, REMAINING) \
+
+// Note, keep an empty line before this line (because of '\')!
+
+#if 0 // ADDITIONAL STATISTICS TO REPORT
+
+REPORT("best",        -1, 2, BEST) \
+REPORT("target",      -1, 2, TARGET) \
+REPORT("maxvar",       0, 2, external->max_var) \
+
+#endif
+
+static const int num_reports =                  // as compile time constant
+#define REPORT(HEAD,PREC,MIN,EXPR) \
+  1 +
+REPORTS
+#undef REPORT
+0;
+
+/*------------------------------------------------------------------------*/
+
+void Internal::report (char type, int verbose) {
+  if (!opts.report) return;
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+  if (opts.quiet || (verbose > opts.verbose)) return;
+  if (!reported) {
+    assert (!lim.report);
+    reported = true;
+    MSG ("%stime measured in %s time %s%s",
+      tout.magenta_code (),
+      internal->opts.realtime ? "real" : "process",
+      internal->opts.reportsolve ? "in solving" : "since initialization",
+      tout.normal_code ());
+  }
+  Report reports[num_reports];
+  int n = 0;
+#define REPORT(HEAD,PREC,MIN,EXPR) \
+  assert (n < num_reports); \
+  reports[n++] = Report (HEAD, PREC, MIN, (double)(EXPR));
+  REPORTS
+#undef REPORT
+  if (!lim.report) {
+    print_prefix ();
+    fputc ('\n', stdout);
+    int pos = 4;
+    for (int i = 0; i < n; i++) {
+      int len = strlen (reports[i].buffer);
+      reports[i].pos = pos + (len + 1)/2;
+      pos += len + 1;
+    }
+    const int max_line = pos + 20, nrows = 3;
+    char *line = new char[max_line];
+    for (int start = 0; start < nrows; start++) {
+      int i;
+      for (i = 0; i < max_line; i++)
+        line[i] = ' ';
+      for (i = start; i < n; i += nrows)
+        reports[i].print_header (line);
+      for (i = max_line-1; line[i-1] == ' '; i--)
+        ;
+      line[i] = 0;
+      print_prefix ();
+      tout.yellow ();
+      fputs (line, stdout);
+      tout.normal ();
+      fputc ('\n', stdout);
+    }
+    print_prefix ();
+    fputc ('\n', stdout);
+    delete [] line;
+    lim.report = 19;
+  } else lim.report--;
+  print_prefix ();
+  switch (type) {
+    case '[': case ']':           tout.magenta (true); break;
+    case 's': case 'v': case 'w':
+    case 't': case 'b': case 'c': tout.green (false); break;
+    case 'e':                     tout.green (true); break;
+    case 'p': case '2': case '3': tout.blue (false); break;
+    case 'd':                     tout.blue (true); break;
+    case 'z': case 'f':           tout.cyan (true); break;
+    case '-':                     tout.normal (); break;
+    case '/':                     tout.yellow (true); break;
+    case 'a': case 'n':           tout.red (false); break;
+    case '0': case '1': case '?':
+    case 'i':                     tout.bold (); break;
+    case 'L': case 'P':           tout.bold (); tout.underline (); break;
+  }
+  fputc (type, stdout);
+  if (stable || type == ']') tout.magenta ();
+  else if (type != 'L' && type != 'P') tout.normal ();
+  for (int i = 0; i < n; i++) {
+    fputc (' ', stdout);
+    fputs (reports[i].buffer, stdout);
+  }
+  if (stable || type == 'L' || type == 'P' || type == ']') tout.normal ();
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#else // ifndef QUIET
+
+void Internal::report (char, int) { }
+
+#endif
+
+}
diff --git a/hCaD_V2/src/resources.cpp b/hCaD_V2/src/resources.cpp
new file mode 100644
index 0000000..f4f72cc
--- /dev/null
+++ b/hCaD_V2/src/resources.cpp
@@ -0,0 +1,145 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// This is operating system specific code.  We mostly develop on Linux and
+// there it should be fine and mostly works out-of-the-box on MacOS too but
+// Windows needs special treatment (as probably other operating systems too).
+
+extern "C" {
+
+#ifdef __WIN32
+
+#ifndef __WIN32_WINNT
+#define __WIN32_WINNT 0x0600
+#endif
+
+#include <windows.h>
+#include <psapi.h>
+
+#else
+
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#endif
+
+#include <string.h>
+}
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+#ifdef __WIN32
+
+double absolute_real_time () {
+  FILETIME f;
+  GetSystemTimeAsFileTime(&f);
+  ULARGE_INTEGER t;
+  t.LowPart = f.dwLowDateTime;
+  t.HighPart = f.dwHighDateTime;
+  double res = (__int64) t.QuadPart;
+  res *= 1e-7;
+  return res;
+}
+
+double absolute_process_time () {
+  double res = 0;
+  FILETIME fc, fe, fu, fs;
+  if (GetProcessTimes (GetCurrentProcess (), &fc, &fe, &fu, &fs)) {
+    ULARGE_INTEGER u, s;
+    u.LowPart = fu.dwLowDateTime;
+    u.HighPart = fu.dwHighDateTime;
+    s.LowPart = fs.dwLowDateTime;
+    s.HighPart = fs.dwHighDateTime;
+    res = (__int64) u.QuadPart + (__int64) s.QuadPart;
+    res *= 1e-7;
+  }
+  return res;
+}
+
+#else
+
+double absolute_real_time () {
+  struct timeval tv;
+  if (gettimeofday (&tv, 0)) return 0;
+  return 1e-6 * tv.tv_usec + tv.tv_sec;
+}
+
+// We use 'getrusage' for 'process_time' and 'maximum_resident_set_size'
+// which is pretty standard on Unix but probably not available on Windows
+// etc.  For different variants of Unix not all fields are meaningful.
+
+double absolute_process_time () {
+  double res;
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u)) return 0;
+  res = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;  // user time
+  res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec; // + system time
+  return res;
+}
+
+#endif
+
+double Internal::real_time () {
+  return absolute_real_time () - stats.time.real;
+}
+
+double Internal::process_time () {
+  return absolute_process_time () - stats.time.process;
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifdef __WIN32
+
+uint64_t current_resident_set_size () {
+  PROCESS_MEMORY_COUNTERS pmc;
+  if (GetProcessMemoryInfo (GetCurrentProcess (), &pmc, sizeof (pmc))) {
+     return pmc.WorkingSetSize;
+  } else return 0;
+}
+
+uint64_t maximum_resident_set_size () {
+  PROCESS_MEMORY_COUNTERS pmc;
+  if (GetProcessMemoryInfo (GetCurrentProcess (), &pmc, sizeof (pmc))) {
+     return pmc.PeakWorkingSetSize;
+  } else return 0;
+}
+
+#else
+
+// This seems to work on Linux (man page says since Linux 2.6.32).
+
+uint64_t maximum_resident_set_size () {
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u)) return 0;
+  return ((uint64_t) u.ru_maxrss) << 10;
+}
+
+// Unfortunately 'getrusage' on Linux does not support current resident set
+// size (the field 'ru_ixrss' is there but according to the man page
+// 'unused'). Thus we fall back to use the '/proc' file system instead.  So
+// this is not portable at all and needs to be replaced on other systems
+// The code would still compile though (assuming 'sysconf' and
+// '_SC_PAGESIZE' are available).
+
+uint64_t current_resident_set_size () {
+  char path[40];
+  sprintf (path, "/proc/%" PRId64 "/statm", (int64_t) getpid ());
+  FILE * file = fopen (path, "r");
+  if (!file) return 0;
+  uint64_t dummy, rss;
+  int scanned = fscanf (file, "%" PRIu64 " %" PRIu64 "", &dummy, &rss);
+  fclose (file);
+  return scanned == 2 ? rss * sysconf (_SC_PAGESIZE) : 0;
+}
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+}
diff --git a/hCaD_V2/src/resources.hpp b/hCaD_V2/src/resources.hpp
new file mode 100644
index 0000000..7ecc6e8
--- /dev/null
+++ b/hCaD_V2/src/resources.hpp
@@ -0,0 +1,14 @@
+#ifndef _resources_hpp_INCLUDED
+#define _resources_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+double absolute_real_time ();
+double absolute_process_time ();
+
+uint64_t maximum_resident_set_size ();
+uint64_t current_resident_set_size ();
+
+}
+
+#endif // ifndef _resources_hpp_INCLUDED
diff --git a/hCaD_V2/src/restart.cpp b/hCaD_V2/src/restart.cpp
new file mode 100644
index 0000000..20df6d2
--- /dev/null
+++ b/hCaD_V2/src/restart.cpp
@@ -0,0 +1,109 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// As observed by Chanseok Oh and implemented in MapleSAT solvers too,
+// various mostly satisfiable instances benefit from long quiet phases
+// with less or almost no restarts.  We implement this idea by prohibiting
+// the Glucose style restart scheme in a geometric fashion, which is very
+// similar to how originally restarts were scheduled in MiniSAT and earlier
+// solvers.  We start with say 1e3 = 1000 (opts.stabilizeinit) conflicts of
+// Glucose restarts.  Then in a "stabilizing" phase we disable these
+// until 1e4 = 2000 conflicts (if 'opts.stabilizefactor' is '200' percent)
+// have passed. After that we switch back to regular Glucose style restarts
+// until again 2 times more conflicts than the previous limit are reached.
+// Actually, in the latest version we still restarts during stabilization
+// but only in a reluctant doubling scheme with a rather high interval.
+
+bool Internal::stabilizing () {
+  if (!opts.stabilize) return false;
+  if (stable && opts.stabilizeonly) return true;
+  if (stats.conflicts >= lim.stabilize) {
+    report (stable ? ']' : '}');
+    if (stable) STOP (stable);
+    else        STOP (unstable);
+    stable = !stable;
+    if (stable) stats.stabphases++;
+    PHASE ("stabilizing", stats.stabphases,
+      "reached stabilization limit %" PRId64 " after %" PRId64 " conflicts",
+      lim.stabilize, stats.conflicts);
+    inc.stabilize *= opts.stabilizefactor*1e-2;
+    if (inc.stabilize > opts.stabilizemaxint)
+      inc.stabilize = opts.stabilizemaxint;
+    lim.stabilize = stats.conflicts + inc.stabilize;
+    if (lim.stabilize <= stats.conflicts)
+      lim.stabilize = stats.conflicts + 1;
+    swap_averages ();
+    PHASE ("stabilizing", stats.stabphases,
+      "new stabilization limit %" PRId64 " at conflicts interval %" PRId64 "",
+      lim.stabilize, inc.stabilize);
+    report (stable ? '[' : '{');
+    if (stable) START (stable);
+    else        START (unstable);
+  }
+  return stable;
+}
+
+// Restarts are scheduled by a variant of the Glucose scheme as presented in
+// our POS'15 paper using exponential moving averages.  There is a slow
+// moving average of the average recent glucose level of learned clauses as
+// well as a fast moving average of those glues.  If the end of a base
+// restart conflict interval has passed and the fast moving average is above
+// a certain margin over the slow moving average then we restart.
+
+bool Internal::restarting () {
+  if (!opts.restart) return false;
+  if ((size_t) level < assumptions.size () + 2) return false;
+  if (stabilizing ()) return reluctant;
+  if (stats.conflicts <= lim.restart) return false;
+  double f = averages.current.glue.fast;
+  double margin = (100.0 + opts.restartmargin)/100.0;
+  double s = averages.current.glue.slow, l = margin * s;
+  LOG ("EMA glue slow %.2f fast %.2f limit %.2f", s, f, l);
+  return l <= f;
+}
+
+// This is Marijn's reuse trail idea.  Instead of always backtracking to the
+// top we figure out which decisions will be made again anyhow and only
+// backtrack to the level of the last such decision or to the top if no such
+// decision exists top (in which case we do not reuse any level).
+
+int Internal::reuse_trail () {
+  if (!opts.restartreusetrail) return assumptions.size ();
+  int decision = next_decision_variable ();
+  assert (1 <= decision);
+  int res = assumptions.size ();
+  if (use_scores ()) {
+    while (res < level &&
+           score_smaller (this)(decision, abs (control[res+1].decision)))
+      res++;
+  } else {
+    int64_t limit = bumped (decision);
+    while (res < level && bumped (control[res+1].decision) > limit)
+      res++;
+  }
+  int reused = res - assumptions.size ();
+  if (reused > 0) {
+    stats.reused++;
+    stats.reusedlevels += reused;
+    if (stable) stats.reusedstable++;
+  }
+  return res;
+}
+
+void Internal::restart () {
+  START (restart);
+  stats.restarts++;
+  stats.restartlevels += level;
+  if (stable) stats.restartstable++;
+  LOG ("restart %" PRId64 "", stats.restarts);
+  backtrack (reuse_trail ());
+
+  lim.restart = stats.conflicts + opts.restartint;
+  LOG ("new restart limit at %" PRId64 " conflicts", lim.restart);
+
+  report ('R', 2);
+  STOP (restart);
+}
+
+}
diff --git a/hCaD_V2/src/restore.cpp b/hCaD_V2/src/restore.cpp
new file mode 100644
index 0000000..39f07a7
--- /dev/null
+++ b/hCaD_V2/src/restore.cpp
@@ -0,0 +1,220 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// In incremental solving after a first call to 'solve' has finished and
+// before calling the internal 'solve' again incrementally we have to
+// restore clauses which have the negation of a literal as a witness literal
+// on the extension stack, which was added as original literal in a new
+// clause or in an assumption.  This procedure has to be applied
+// recursively, i.e., the literals of restored clauses are treated in the
+// same way as literals of a new original clause.
+//
+// To figure out whether literals are such witnesses we have a 'witness'
+// bit for each external literal, which is set in 'block', 'elim', and
+// 'decompose' if a clause is pushed on the extension stack.  The witness
+// bits are recomputed after restoring clauses.
+//
+// We further mark in the external solver newly internalized external
+// literals in 'add' and 'assume' since the last call to 'solve' as tainted
+// if they occur negated as a witness literal on the extension stack.  Then
+// we go through the extension stack and restore all clauses which have a
+// tainted literal (and its negation a marked as witness).
+//
+// Since the API contract disallows to call 'val' and 'failed' in an
+// 'UNKNOWN' state. We do not have to internalize literals there.
+//
+// In order to have tainted literals accepted by the internal solver they
+// have to be active and thus we might need to 'reactivate' them before
+// restoring clauses if they are inactive. In case they have completely
+// been eliminated and removed from the internal solver in 'compact', then
+// we just use a new internal variable.  This is performed in 'internalize'
+// during marking external literals as tainted.
+//
+// To check that this approach is correct the external solver can maintain a
+// stack of original clauses and current assumptions both in terms of
+// external literals.  Whenever 'solve' determines that the current
+// incremental call is satisfiable we check that the (extended) witness does
+// satisfy the saved original clauses, as well as all the assumptions. To
+// enable these checks set 'opts.check' as well as 'opts.checkwitness' and
+// 'opts.checkassumptions' all to 'true'.  The model based tester actually
+// prefers to enable the 'opts.check' option and the other two are 'true' by
+// default anyhow.
+//
+// See our SAT'19 paper [FazekasBiereScholl-SAT'19] for more details.
+
+/*------------------------------------------------------------------------*/
+
+void External::restore_clause (
+  const vector<int>::const_iterator & begin,
+  const vector<int>::const_iterator & end) {
+  LOG (begin, end, "restoring external clause");
+  for (auto p = begin; p != end; p++) {
+    int ilit = internalize (*p);
+    internal->add_original_lit (ilit);
+    internal->stats.restoredlits++;
+  }
+  internal->add_original_lit (0);
+  internal->stats.restored++;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::restore_clauses () {
+
+  assert (internal->opts.restoreall == 2 || !tainted.empty ());
+
+  START (restore);
+  internal->stats.restorations++;
+
+  struct { int64_t weakened, satisfied, restored, removed; } clauses;
+  memset (&clauses, 0, sizeof clauses);
+
+  if (internal->opts.restoreall && tainted.empty ())
+    PHASE ("restore", internal->stats.restorations,
+      "forced to restore all clauses");
+
+  unsigned numtainted = 0;
+  for (const auto & b : tainted)
+    if (b) numtainted++;
+
+  PHASE ("restore", internal->stats.restorations,
+    "starting with %u tainted literals %.0f%%",
+    numtainted, percent (numtainted, 2u*max_var));
+
+  auto end_of_extension = extension.end ();
+  auto p = extension.begin (), q = p;
+
+  // Go over all witness labelled clauses on the extension stack, restore
+  // those necessary, remove restored and flush satisfied clauses.
+  //
+  while (p != end_of_extension) {
+
+    clauses.weakened++;
+
+    assert (!*p);
+    const auto saved = q;                       // Save old start.
+    *q++ = *p++;                                // Copy zero '0'.
+
+    // Copy witness part and try to find a tainted witness literal in it.
+    //
+    int tlit = 0;                               // Negation tainted.
+    int elit;
+    //
+    assert (p != end_of_extension);
+    //
+    while ((elit = *q++ = *p++)) {
+
+      if (marked (tainted, -elit)) {
+        tlit = elit;
+        LOG ("negation of witness literal %d tainted", tlit);
+      }
+
+      assert (p != end_of_extension);
+    }
+
+    // Now find 'end_of_clause' (clause starts at 'p') and at the same time
+    // figure out whether the clause is actually root level satisfied.
+    //
+    int satisfied = 0;
+    auto end_of_clause = p;
+    while (end_of_clause != end_of_extension && (elit = *end_of_clause)) {
+      if (!satisfied && fixed (elit) > 0)
+        satisfied = elit;
+      end_of_clause++;
+    }
+
+    // Do not apply our 'FLUSH' rule to remove satisfied (implied) clauses
+    // if the corresponding option is set simply by resetting 'satisfied'.
+    //
+    if (satisfied && !internal->opts.restoreflush) {
+      LOG (p, end_of_clause,
+        "forced to not remove %d satisfied", satisfied);
+      satisfied = 0;
+    }
+
+    if (satisfied || tlit || internal->opts.restoreall) {
+
+      if (satisfied) {
+        LOG (p, end_of_clause,
+          "flushing implied clause satisfied by %d from extension stack",
+          satisfied);
+        clauses.satisfied++;
+      } else {
+        restore_clause (p, end_of_clause);      // Might taint literals.
+        clauses.restored++;
+      }
+
+      clauses.removed++;
+      p = end_of_clause;
+      q = saved;
+
+    } else {
+
+      LOG (p, end_of_clause, "keeping clause on extension stack");
+
+      while (p != end_of_clause)                // Copy clause too.
+        *q++ = *p++;
+    }
+  }
+
+  extension.resize (q - extension.begin ());
+  shrink_vector (extension);
+
+#ifndef QUIET
+  if (clauses.satisfied)
+    PHASE ("restore", internal->stats.restorations,
+      "removed %" PRId64 " satisfied %.0f%% of %" PRId64 " weakened clauses",
+      clauses.satisfied,
+      percent (clauses.satisfied, clauses.weakened),
+      clauses.weakened);
+  else
+    PHASE ("restore", internal->stats.restorations,
+      "no satisfied clause removed out of %" PRId64 " weakened clauses",
+      clauses.weakened);
+
+  if (clauses.restored)
+    PHASE ("restore", internal->stats.restorations,
+      "restored %" PRId64 " clauses %.0f%% out of %" PRId64 " weakened clauses",
+      clauses.restored,
+      percent (clauses.restored, clauses.weakened),
+      clauses.weakened);
+  else
+    PHASE ("restore", internal->stats.restorations,
+      "no clause restored out of %" PRId64 " weakened clauses",
+      clauses.weakened);
+#endif
+
+  numtainted = 0;
+  for (const auto & b : tainted)
+    if (b) numtainted++;
+
+  PHASE ("restore", internal->stats.restorations,
+    "finishing with %u tainted literals %.0f%%",
+    numtainted, percent (numtainted, 2u*max_var));
+
+  LOG ("extension stack clean");
+  tainted.clear ();
+
+  // Finally recompute the witness bits.
+  //
+  witness.clear ();
+  const auto begin_of_extension = extension.begin ();
+  p = extension.end ();
+  while (p != begin_of_extension) {
+    while (*--p)
+      assert (p != begin_of_extension);
+    int elit;
+    assert (p != begin_of_extension);
+    while ((elit = *--p)) {
+      mark (witness, elit);
+      assert (p != begin_of_extension);
+    }
+  }
+
+  STOP (restore);
+}
+
+}
diff --git a/hCaD_V2/src/score.cpp b/hCaD_V2/src/score.cpp
new file mode 100644
index 0000000..a9eea6a
--- /dev/null
+++ b/hCaD_V2/src/score.cpp
@@ -0,0 +1,49 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// This initializes variables on the binary 'scores' heap also with
+// smallest variable index first (thus picked first) and larger indices at
+// the end.
+//
+void Internal::init_scores (int old_max_var, int new_max_var) {
+  LOG ("initializing EVSIDS scores from %d to %d",
+    old_max_var + 1, new_max_var);
+  for (int i = old_max_var; i < new_max_var; i++)
+    scores.push_back (i + 1);
+}
+
+// Shuffle the EVSIDS heap.
+
+void Internal::shuffle_scores () {
+  if (!opts.shuffle) return;
+  if (!opts.shufflescores) return;
+  assert (!level);
+  stats.shuffled++;
+  LOG ("shuffling scores");
+  vector<int> shuffle;
+  if (opts.shufflerandom){
+    scores.erase ();
+    for (int idx = max_var; idx; idx--)
+      shuffle.push_back (idx);
+    Random random (opts.seed);                  // global seed
+    random += stats.shuffled;                   // different every time
+    for (int i = 0; i <= max_var-2; i++) {
+      const int j = random.pick_int (i, max_var-1);
+      swap (shuffle[i], shuffle[j]);
+    }
+  } else {
+    while (!scores.empty ()) {
+      int idx = scores.front ();
+      (void) scores.pop_front ();
+      shuffle.push_back (idx);
+    }
+  }
+  score_inc = 0;
+  for (const auto & idx : shuffle) {
+    stab[idx] = score_inc++;
+    scores.push_back (idx);
+  }
+}
+
+}
diff --git a/hCaD_V2/src/score.hpp b/hCaD_V2/src/score.hpp
new file mode 100644
index 0000000..1911186
--- /dev/null
+++ b/hCaD_V2/src/score.hpp
@@ -0,0 +1,16 @@
+#ifndef _score_hpp_INCLUDED
+#define _score_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct score_smaller {
+  Internal * internal;
+  score_smaller (Internal * i) : internal (i) { }
+  bool operator () (unsigned a, unsigned b);
+};
+
+typedef heap<score_smaller> ScoreSchedule;
+
+}
+
+#endif
diff --git a/hCaD_V2/src/shrink.cpp b/hCaD_V2/src/shrink.cpp
new file mode 100644
index 0000000..3b5228a
--- /dev/null
+++ b/hCaD_V2/src/shrink.cpp
@@ -0,0 +1,446 @@
+#include "internal.hpp"
+#include "reap.hpp"
+
+namespace CaDiCaL {
+
+  void Internal::reset_shrinkable()
+  {
+    size_t reset = 0;
+    for(const auto & lit : shrinkable) {
+      LOG("resetting lit %i", lit);
+      Flags &f = flags(lit);
+      assert(f.shrinkable);
+      f.shrinkable = false;
+      ++reset;
+    }
+    LOG("resetting %zu shrinkable variables", reset);
+  }
+
+  void Internal::mark_shrinkable_as_removable(int blevel, std::vector<int>::size_type minimized_start) {
+    size_t marked = 0, reset = 0;
+#ifndef NDEBUG
+    unsigned kept = 0, minireset = 0;
+    for(; minimized_start < minimized.size(); ++minimized_start) {
+      const int lit = minimized[minimized_start];
+      Flags &f = flags(lit);
+      const Var &v = var(lit);
+      if (v.level == blevel) {
+        assert(!f.poison);
+        ++minireset;
+      }
+      else ++kept;
+    }
+#else
+    (void) blevel;
+    (void) minimized_start;
+#endif
+
+
+    for (const int lit : shrinkable) {
+      Flags &f = flags(lit);
+      assert(f.shrinkable);
+      assert(!f.poison);
+      f.shrinkable = false;
+      ++reset;
+      if(f.removable)
+        continue;
+      f.removable = true;
+      minimized.push_back(lit);
+      ++marked;
+    }
+    LOG("resetting %zu shrinkable variables", reset);
+    LOG("marked %zu removable variables", marked);
+  }
+
+  int inline Internal::shrink_literal(int lit, int blevel, unsigned max_trail)
+  {
+    assert(val(lit) < 0);
+
+    Flags &f = flags(lit);
+    const Var &v = var(lit);
+    assert(v.level <= blevel);
+
+    if(!v.level) {
+      LOG("skipping root level assigned %d", (lit));
+      return 0;
+    }
+    if (f.shrinkable) {
+      LOG("skipping already shrinkable literal %d", (lit));
+      return 0;
+    }
+
+    if (v.level < blevel) {
+      if (f.removable) {
+        LOG("skipping removable thus shrinkable %d", (lit));
+        return 0;
+      }
+      const bool always_minimize_on_lower_blevel = (opts.shrink > 2);
+      if (always_minimize_on_lower_blevel &&
+          minimize_literal(-lit, 1)) {
+        LOG("minimized thus shrinkable %d", (lit));
+        return 0;
+      }
+      LOG("literal %d on lower blevel %u < %u not removable/shrinkable",
+          (lit), v.level, blevel);
+      return -1;
+    }
+
+    LOG("marking %d as shrinkable", lit);
+    f.shrinkable = true;
+    f.poison = false;
+    shrinkable.push_back(lit);
+    if (opts.shrinkreap) {
+      assert (max_trail < trail.size());
+      const unsigned dist = max_trail - v.trail;
+      reap.push(dist);
+    }
+    return 1;
+  }
+
+  unsigned Internal::shrunken_block_uip(
+      int uip, int blevel, std::vector<int>::reverse_iterator &rbegin_block,
+      std::vector<int>::reverse_iterator &rend_block,
+      std::vector<int>::size_type minimized_start, const int uip0)
+  {
+    assert(clause[0] == uip0);
+
+    LOG("UIP on level %u, uip: %i (replacing by %i)", blevel, uip, uip0);
+    assert(rend_block > rbegin_block);
+    assert(rend_block < clause.rend());
+    unsigned block_shrunken = 0;
+    *rbegin_block = -uip;
+    Var &v = var(-uip);
+    Level &l = control[v.level];
+    l.seen.trail = v.trail;
+    l.seen.count = 1;
+
+    Flags &f = flags(-uip);
+    if(!f.seen) {
+      analyzed.push_back(-uip);
+      f.seen = true;
+    }
+
+    flags(-uip).keep = true;
+    for (auto p = rbegin_block + 1; p != rend_block; ++p) 
+      {
+        const int lit = *p;
+        if (lit == -uip0) continue;
+        *p = uip0;
+        // if (lit == -uip) continue;
+        ++block_shrunken;
+        assert(clause[0] == uip0);
+      }
+    mark_shrinkable_as_removable(blevel, minimized_start);
+    assert(clause[0] == uip0);
+    return block_shrunken;
+  }
+
+  void inline Internal::shrunken_block_no_uip(
+                                              const std::vector<int>::reverse_iterator &rbegin_block,
+                                              const std::vector<int>::reverse_iterator &rend_block,
+                                              unsigned &block_minimized,
+                                              const int uip0) {
+    STOP(shrink);
+    START(minimize);
+    assert(rend_block > rbegin_block);
+    LOG("no UIP found, now minimizing");
+    for (auto p = rbegin_block; p != rend_block; ++p) {
+      assert(p != clause.rend() - 1);
+      const int lit = *p;
+      if (opts.minimize && minimize_literal(-lit)) {
+        assert(!flags(lit).keep);
+        ++block_minimized;
+        *p = uip0;
+      } else {
+        flags(lit).keep = true;
+        assert(flags(lit).keep);
+      }
+    }
+    STOP(minimize);
+    START(shrink);
+  }
+
+  void Internal::push_literals_of_block(const std::vector<int>::reverse_iterator &rbegin_block,
+                                        const std::vector<int>::reverse_iterator &rend_block,
+                                        int blevel, unsigned max_trail)
+  {
+    assert(rbegin_block < rend_block);
+    for(auto p = rbegin_block; p != rend_block; ++p) {
+      assert(p != clause.rend() - 1);
+      assert(!flags(*p).keep);
+      const int lit = *p;
+      LOG("pushing lit %i of blevel %i", lit, var(lit).level);
+#ifndef NDEBUG
+      int tmp =
+#endif
+        shrink_literal(lit, blevel, max_trail);
+      assert(tmp > 0);
+    }
+  }
+
+  unsigned inline Internal::shrink_next(unsigned &open, unsigned& max_trail)
+  {
+    if(opts.shrinkreap) {
+      assert(!reap.empty());
+      const unsigned dist = reap.pop();
+      --open;
+      assert (dist <= max_trail);
+      const unsigned pos = max_trail - dist;
+      assert(pos < trail.size());
+      const int uip = trail[pos];
+      assert(val(uip) > 0);
+      LOG("trying to shrink literal %d at trail[%u]", uip, pos);
+      return uip;
+    } else {
+      int uip;
+#ifndef NDEBUG
+      unsigned init_max_trail = max_trail;
+#endif
+      do {
+        assert(max_trail <= init_max_trail);
+        uip = trail[max_trail--];
+      } while (!flags (uip).shrinkable);
+      --open;
+      LOG("open is now %d, uip = %d", open, uip);
+      return uip;
+    }
+  }
+
+  unsigned inline Internal::shrink_along_reason(int uip, int blevel, bool resolve_large_clauses, bool &failed_ptr, unsigned max_trail)
+  {
+    LOG("shrinking along the reason of lit %i", uip);
+    unsigned open = 0;
+ #ifndef NDEBUG
+    const Flags&f = flags(uip);
+#endif
+    const Var&v = var(uip);
+
+    assert(f.shrinkable);
+    assert(v.level == blevel);
+    assert(v.reason);
+
+    if (resolve_large_clauses || v.reason->size == 2)
+      {
+        const Clause &c = *v.reason;
+        LOG(v.reason, "resolving with reason");
+        for(int lit : c) {
+          if(lit == uip)
+            continue;
+          assert(val(lit) < 0);
+          int tmp = shrink_literal(lit, blevel, max_trail);
+          if(tmp < 0) {
+            failed_ptr = true;
+            break;
+          }
+          if(tmp > 0) {
+            ++open;
+          }
+        }
+      }
+    else {
+      failed_ptr = true;
+    }
+    return open;
+  }
+
+  unsigned Internal::shrink_block(std::vector<int>::reverse_iterator &rbegin_lits,
+                                  std::vector<int>::reverse_iterator &rend_block,
+                                  int blevel,
+                                  unsigned &open,
+                                  unsigned & block_minimized,
+                                  const int uip0,
+                                  unsigned max_trail)
+  {
+    assert(shrinkable.empty());
+    assert(blevel <= this->level);
+    assert(open < clause.size());
+    assert(rbegin_lits >= clause.rbegin());
+    assert(rend_block < clause.rend());
+    assert(rbegin_lits < rend_block);
+
+    LOG("trying to shrink %u literals on level %u", open, blevel);
+    LOG("maximum trail position %zd on level %u", trail.size(), blevel);
+    if (opts.shrinkreap)
+      LOG ("shrinking up to %u", max_trail);
+
+    const bool resolve_large_clauses = (opts.shrink > 2);
+    bool failed = (opts.shrink == 0);
+    unsigned block_shrunken = 0;
+    std::vector<int>::size_type minimized_start = minimized.size();
+    int uip = uip0;
+    unsigned max_trail2 = max_trail;
+
+    if(!failed) {
+      push_literals_of_block(rbegin_lits, rend_block, blevel, max_trail);
+      assert(!opts.shrinkreap || reap.size() == open);
+
+      assert(open > 0);
+      while (!failed) {
+        assert(!opts.shrinkreap || reap.size() == open);
+        uip = shrink_next(open, max_trail);
+        if(open == 0) {
+          break;
+        }
+        open += shrink_along_reason(uip, blevel, resolve_large_clauses, failed, max_trail2);
+        assert(open >= 1);
+      }
+
+      if(!failed)
+        LOG("shrinking found UIP %i on level %i (open: %d)", uip, blevel, open);
+      else
+        LOG("shrinking failed on level %i", blevel);
+    }
+
+    if(failed)
+      reset_shrinkable(), shrunken_block_no_uip(rbegin_lits, rend_block, block_minimized, uip0);
+    else
+      block_shrunken = shrunken_block_uip(uip, blevel, rbegin_lits, rend_block, minimized_start, uip0);
+
+    if(opts.shrinkreap)
+      reap.clear();
+    shrinkable.clear();
+    return block_shrunken;
+  }
+
+  // Smaller level and trail.  Comparing literals on their level is necessary
+  // for chronological backtracking, since trail order might in this case not
+  // respect level order.
+
+  struct shrink_trail_negative_rank {
+    Internal *internal;
+    shrink_trail_negative_rank(Internal *s) : internal(s) {}
+    typedef uint64_t Type;
+    Type operator()(int a) {
+      Var &v = internal->var(a);
+      uint64_t res = v.level;
+      res <<= 32;
+      res |= v.trail;
+      return ~res;
+    }
+  };
+
+  struct shrink_trail_larger {
+    Internal *internal;
+    shrink_trail_larger(Internal *s) : internal(s) {}
+    bool operator()(const int &a, const int &b) const {
+      return shrink_trail_negative_rank(internal)(a) <
+             shrink_trail_negative_rank(internal)(b);
+    }
+  };
+
+  // Finds the beginning of the block (rend_block, non-included) ending at rend_block (included).
+  // Then tries to shrinks and minimizes literals  the block
+  std::vector<int>::reverse_iterator Internal::minimize_and_shrink_block(
+          std::vector<int>::reverse_iterator &rbegin_block, unsigned &total_shrunken,
+          unsigned &total_minimized,
+          const int uip0)
+
+  {
+    LOG("shrinking block");
+    assert(rbegin_block < clause.rend() -1);
+    int blevel;
+    unsigned open = 0;
+    unsigned max_trail;
+ 
+    // find begining of block;
+    std::vector<int>::reverse_iterator rend_block;
+    {
+      assert(rbegin_block <= clause.rend());
+      const int lit = *rbegin_block;
+      const int idx = vidx (lit);
+      blevel = vtab[idx].level;
+      max_trail = vtab[idx].trail;
+      LOG("Block at level %i (first lit: %i)", blevel, lit);
+
+
+      rend_block = rbegin_block;
+      bool finished;
+      do {
+        assert(rend_block < clause.rend() - 1);
+        const int lit = *(++rend_block);
+        const int idx = vidx (lit);
+        finished = (blevel != vtab[idx].level);
+        if(!finished && (unsigned)vtab[idx].trail > max_trail)
+          max_trail = vtab[idx].trail;
+        ++ open;
+        LOG("testing if lit %i is on the same level (of lit: %i, global: %i)", lit, vtab[idx].level, blevel);
+
+      } while(!finished);
+
+    }
+    assert(open > 0);
+    assert(open < clause.size());
+    assert(rbegin_block < clause.rend());
+    assert(rend_block < clause.rend());
+
+    unsigned block_shrunken = 0, block_minimized = 0;
+    if (open < 2) {
+        flags(*rbegin_block).keep = true;
+        minimized.push_back(*rbegin_block);
+    }
+    else
+      block_shrunken = shrink_block(rbegin_block, rend_block, blevel, open, block_minimized, uip0, max_trail);
+
+    LOG("shrunken %u literals on level %u (including %u minimized)",
+        block_shrunken, blevel, block_minimized);
+
+    total_shrunken += block_shrunken;
+    total_minimized += block_minimized;
+
+    return rend_block;
+  }
+
+  void Internal::shrink_and_minimize_clause() {
+    assert(opts.minimize || opts.shrink > 0);
+    LOG(clause, "shrink first UIP clause");
+
+    START(shrink);
+    external->check_learned_clause(); // check 1st UIP learned clause first
+    MSORT(opts.radixsortlim, clause.begin(), clause.end(),
+          shrink_trail_negative_rank(this), shrink_trail_larger(this));
+    unsigned total_shrunken = 0;
+    unsigned total_minimized = 0;
+
+    LOG(clause, "shrink first UIP clause (asserting lit: %i)", clause[0]);
+
+    auto rend_lits = clause.rend() -1;
+    auto rend_block = clause.rbegin();
+    const int uip0 = clause[0];
+
+    while (rend_block != rend_lits) {
+      rend_block = minimize_and_shrink_block(rend_block,
+                                             total_shrunken, total_minimized, uip0);
+    }
+
+    LOG(clause, "post shrink pass (with uips, not removed) first UIP clause");
+#if defined(LOGGING) || !defined(NDEBUG)
+    const unsigned old_size = clause.size();
+#endif
+    {
+      std::vector<int>::size_type i = 1;
+      for (std::vector<int>::size_type j = 1; j < clause.size(); ++j) {
+        assert(i <= j);
+        clause[i] = clause[j];
+        if (clause[j] == uip0)
+          continue;
+        assert(flags(clause[i]).keep);
+        ++i;
+        LOG("keeping literal %i", clause[j]);
+      }
+      clause.resize(i);
+    }
+    assert(old_size == (unsigned)clause.size() + total_shrunken + total_minimized);
+    LOG(clause, "after shrinking first UIP clause");
+    LOG("clause shrunken by %zd literals (including %u minimized)", old_size - clause.size(),
+        total_minimized);
+
+    stats.shrunken += total_shrunken;
+    stats.minishrunken += total_minimized;
+    STOP(shrink);
+
+    START(minimize);
+    clear_minimized_literals();
+    STOP(minimize);
+  }
+
+} // namespace CaDiCaL
diff --git a/hCaD_V2/src/signal.cpp b/hCaD_V2/src/signal.cpp
new file mode 100644
index 0000000..f134aa7
--- /dev/null
+++ b/hCaD_V2/src/signal.cpp
@@ -0,0 +1,132 @@
+#include "cadical.hpp"
+#include "resources.hpp"
+#include "signal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+#include <csignal>
+#include <cassert>
+
+/*------------------------------------------------------------------------*/
+
+extern "C" {
+#include <unistd.h>
+}
+
+/*------------------------------------------------------------------------*/
+
+// Signal handlers for printing statistics even if solver is interrupted.
+
+namespace CaDiCaL {
+
+static volatile bool caught_signal = false;
+static Handler * signal_handler;
+
+#ifndef __WIN32
+
+static volatile bool caught_alarm = false;
+static volatile bool alarm_set = false;
+static int alarm_time = -1;
+
+void Handler::catch_alarm () { catch_signal (SIGALRM); }
+
+#endif
+
+#define SIGNALS \
+SIGNAL(SIGABRT) \
+SIGNAL(SIGINT) \
+SIGNAL(SIGSEGV) \
+SIGNAL(SIGTERM) \
+
+#define SIGNAL(SIG) \
+static void (*SIG ## _handler)(int);
+SIGNALS
+#undef SIGNAL
+static void (*SIGALRM_handler)(int);
+
+#ifndef __WIN32
+
+void Signal::reset_alarm () {
+  if (!alarm_set) return;
+  (void) signal (SIGALRM, SIGALRM_handler);
+  SIGALRM_handler = 0;
+  caught_alarm = false;
+  alarm_set = false;
+  alarm_time = -1;
+}
+
+#endif
+
+void Signal::reset () {
+  signal_handler = 0;
+#define SIGNAL(SIG) \
+  (void) signal (SIG, SIG ## _handler); \
+  SIG ## _handler = 0;
+SIGNALS
+#undef SIGNAL
+#ifndef __WIN32
+  reset_alarm ();
+#endif
+  caught_signal = false;
+}
+
+const char * Signal::name (int sig) {
+#define SIGNAL(SIG) \
+  if (sig == SIG) return # SIG;
+  SIGNALS
+#undef SIGNAL
+#ifndef __WIN32
+  if (sig == SIGALRM) return "SIGALRM";
+#endif
+  return "UNKNOWN";
+}
+
+// TODO printing is not reentrant and might lead to deadlock if the signal
+// is raised during another print attempt (and locked IO is used).  To avoid
+// this we have to either run our own low-level printing routine here or in
+// 'Message' or just dump those statistics somewhere else were we have
+// exclusive access to.  All these solutions are painful and not elegant.
+
+static void catch_signal (int sig) {
+#ifndef __WIN32
+  if (sig == SIGALRM && absolute_real_time () >= alarm_time) {
+    if (!caught_alarm) {
+      caught_alarm = true;
+      if (signal_handler) signal_handler->catch_alarm ();
+    }
+    Signal::reset_alarm ();
+  } else 
+#endif
+  {
+    if (!caught_signal) {
+      caught_signal = true;
+      if (signal_handler) signal_handler->catch_signal (sig);
+    }
+    Signal::reset ();
+    ::raise (sig);
+  }
+}
+
+void Signal::set (Handler * h) {
+  signal_handler = h;
+#define SIGNAL(SIG) \
+  SIG ## _handler = signal (SIG, catch_signal);
+SIGNALS
+#undef SIGNAL
+}
+
+#ifndef __WIN32
+
+void Signal::alarm (int seconds) {
+  assert (seconds >= 0);
+  assert (!alarm_set);
+  assert (alarm_time < 0);
+  SIGALRM_handler = signal (SIGALRM, catch_signal);
+  alarm_set = true;
+  alarm_time = absolute_real_time () + seconds;
+  ::alarm (seconds);
+}
+
+#endif
+
+}
diff --git a/hCaD_V2/src/signal.hpp b/hCaD_V2/src/signal.hpp
new file mode 100644
index 0000000..9e29494
--- /dev/null
+++ b/hCaD_V2/src/signal.hpp
@@ -0,0 +1,34 @@
+#ifndef _signal_hpp_INCLUDED
+#define _signal_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+// Helper class for handling signals in applications.
+
+class Handler {
+public:
+  Handler () { }
+  virtual ~Handler () { }
+  virtual void catch_signal (int sig) = 0;
+#ifndef __WIN32
+  virtual void catch_alarm ();
+#endif
+};
+
+class Signal {
+
+public:
+
+  static void set (Handler *);
+  static void reset ();
+#ifndef __WIN32
+  static void alarm (int seconds);
+  static void reset_alarm ();
+#endif
+
+  static const char * name (int sig);
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/solution.cpp b/hCaD_V2/src/solution.cpp
new file mode 100644
index 0000000..4041b65
--- /dev/null
+++ b/hCaD_V2/src/solution.cpp
@@ -0,0 +1,49 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Sam Buss suggested to debug the case where a solver incorrectly claims
+// the formula to be unsatisfiable by checking every learned clause to be
+// satisfied by a satisfying assignment.  Thus the first inconsistent
+// learned clause will be immediately flagged without the need to generate
+// proof traces and perform forward proof checking.  The incorrectly derived
+// clause will raise an abort signal and thus allows to debug the issue with
+// a symbolic debugger immediately.
+
+void External::check_solution_on_learned_clause () {
+  assert (solution);
+  for (const auto & lit : internal->clause)
+    if (sol (internal->externalize (lit)) > 0)
+      return;
+  fatal_message_start ();
+  fputs ("learned clause unsatisfied by solution:\n", stderr);
+  for (const auto & lit : internal->clause)
+    fprintf (stderr, "%d ", lit);
+  fputc ('0', stderr);
+  fatal_message_end ();
+}
+
+void External::check_solution_on_shrunken_clause (Clause * c) {
+  assert (solution);
+  for (const auto & lit : *c)
+    if (sol (internal->externalize (lit)) > 0)
+      return;
+  fatal_message_start ();
+  for (const auto & lit : *c)
+    fprintf (stderr, "%d ", lit);
+  fputc ('0', stderr);
+  fatal_message_end ();
+}
+
+void External::check_no_solution_after_learning_empty_clause () {
+  assert (solution);
+  FATAL ("learned empty clause but got solution");
+}
+
+void External::check_solution_on_learned_unit_clause (int unit) {
+  assert (solution);
+  if (sol (internal->externalize (unit)) > 0) return;
+  FATAL ("learned unit %d contradicts solution", unit);
+}
+
+}
diff --git a/hCaD_V2/src/solver.cpp b/hCaD_V2/src/solver.cpp
new file mode 100644
index 0000000..13c8d72
--- /dev/null
+++ b/hCaD_V2/src/solver.cpp
@@ -0,0 +1,1273 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// See corresponding header file 'cadical.hpp' (!) for more information.
+//
+// Again, to avoid confusion, note that, 'cadical.hpp' is the header file of
+// this file 'solver.cpp', since we want to call the application and main
+// file 'cadical.cpp', while at the same time using 'cadical.hpp' as the
+// main header file of the library (and not 'solver.hpp').
+
+/*------------------------------------------------------------------------*/
+#ifdef LOGGING
+
+// Needs to be kept in sync with the color schemes used in 'logging.cpp'.
+//
+#define api_code blue_code              // API call color
+#define log_code magenta_code           // standard/default logging color
+#define emph_code bright_magenta_code   // emphasized logging color
+
+#endif
+/*------------------------------------------------------------------------*/
+
+// Log state transitions.
+
+#define STATE(S) \
+do { \
+  assert (is_power_of_two (S)); \
+  if (_state == S) break; \
+  _state = S; \
+  LOG ("API enters state %s" #S "%s", \
+    tout.emph_code (), tout.normal_code ()); \
+} while (0)
+
+void Solver::transition_to_unknown_state () {
+  if (state () == CONFIGURING) {
+    LOG ("API leaves state %sCONFIGURING%s",
+      tout.emph_code (), tout.normal_code ());
+    if (internal->opts.check &&
+        internal->opts.checkproof) {
+      internal->check ();
+    }
+  } else if (state () == SATISFIED) {
+    LOG ("API leaves state %sSATISFIED%s",
+      tout.emph_code (), tout.normal_code ());
+    external->reset_assumptions ();
+  } else if (state () == UNSATISFIED) {
+    LOG ("API leaves state %sUNSATISFIED%s",
+      tout.emph_code (), tout.normal_code ());
+    external->reset_assumptions ();
+  }
+  if (state () != UNKNOWN) STATE (UNKNOWN);
+}
+
+/*------------------------------------------------------------------------*/
+#ifdef LOGGING
+/*------------------------------------------------------------------------*/
+
+// The following logging code is useful for debugging mostly (or trying to
+// understand what the solver is actually doing).  It needs to be enabled
+// during configuration using the '-l' option for './configure', which
+// forces 'LOGGING' to be defined during compilation.  This includes all the
+// logging code, which then still needs to enabled during run-time with the
+// '-l' or 'log' option.
+
+static void
+log_api_call (Internal * internal,
+  const char * name, const char * suffix) {
+  Logger::log (internal, "API call %s'%s ()'%s %s",
+    tout.api_code (), name, tout.log_code (), suffix);
+}
+
+static void
+log_api_call (Internal * internal,
+  const char * name, int arg, const char * suffix) {
+  Logger::log (internal, "API call %s'%s (%d)'%s %s",
+    tout.api_code (), name, arg, tout.log_code (), suffix);
+}
+
+static void
+log_api_call (Internal * internal,
+  const char * name, const char * arg, const char * suffix) {
+  Logger::log (internal, "API call %s'%s (\"%s\")'%s %s",
+    tout.api_code (), name, arg, tout.log_code (), suffix);
+}
+
+static void
+log_api_call (Internal * internal,
+  const char * name, const char * a1, int a2, const char * s) {
+  Logger::log (internal, "API call %s'%s (\"%s\", %d)'%s %s",
+    tout.api_code (), name, a1, a2, tout.log_code (), s);
+}
+
+/*------------------------------------------------------------------------*/
+
+// We factored out API call begin/end logging and use overloaded functions.
+
+static void
+log_api_call_begin (Internal * internal, const char * name) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, "started");
+}
+
+static void
+log_api_call_begin (Internal * internal, const char * name, int arg) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg, "started");
+}
+
+static void
+log_api_call_begin (Internal * internal,
+                    const char * name, const char * arg) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg, "started");
+}
+
+static void
+log_api_call_begin (Internal * internal, const char * name,
+                    const char * arg1, int arg2) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg1, arg2, "started");
+}
+
+/*------------------------------------------------------------------------*/
+
+static void
+log_api_call_end (Internal * internal, const char * name)
+{
+  log_api_call (internal, name, "succeeded");
+}
+
+static void
+log_api_call_end (Internal * internal, const char * name, int lit) {
+  log_api_call (internal, name, lit, "succeeded");
+}
+
+static void
+log_api_call_end (Internal * internal,
+                    const char * name, const char * arg) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg, "succeeded");
+}
+
+static void
+log_api_call_end (Internal * internal, const char * name,
+                  const char * arg,
+                  bool res)
+{
+  log_api_call (internal, name, arg, res ? "succeeded" : "failed");
+}
+
+static void
+log_api_call_end (Internal * internal, const char * name,
+                  const char * arg, int val,
+                  bool res)
+{
+  log_api_call (internal, name, arg, val, res ? "succeeded" : "failed");
+}
+
+static void
+log_api_call_returns (Internal * internal, const char * name, bool res) {
+  log_api_call (internal, name,
+    res ? "returns 'true'" : "returns 'false'");
+}
+
+static void
+log_api_call_returns (Internal * internal, const char * name, int res) {
+  char fmt[32];
+  sprintf (fmt, "returns '%d'", res);
+  log_api_call (internal, name, fmt);
+}
+
+static void
+log_api_call_returns (Internal * internal, const char * name, int64_t res) {
+  char fmt[32];
+  sprintf (fmt, "returns '%" PRId64 "'", res);
+  log_api_call (internal, name, fmt);
+}
+
+static void
+log_api_call_returns (Internal * internal,
+                      const char * name, int lit, int res) {
+  char fmt[32];
+  sprintf (fmt, "returns '%d'", res);
+  log_api_call (internal, name, lit, fmt);
+}
+
+static void
+log_api_call_returns (Internal * internal,
+                      const char * name, const char * arg, bool res) {
+  log_api_call (internal, name, arg,
+    res ? "returns 'true'" : "returns 'false'");
+}
+
+static void
+log_api_call_returns (Internal * internal,
+                      const char * name, int lit, bool res) {
+  log_api_call (internal, name, lit,
+    res ? "returns 'true'" : "returns 'false'");
+}
+
+static void
+log_api_call_returns (Internal * internal,
+  const char * name, const char * arg, const char * res) {
+  Logger::log (internal, "API call %s'%s (\"%s\")'%s returns '%s'",
+    tout.api_code (), name, arg, tout.log_code (), res ? res : "<null>");
+}
+
+static void
+log_api_call_returns (Internal * internal,
+  const char * name, const char * arg1, int arg2, const char * res) {
+  Logger::log (internal, "API call %s'%s (\"%s\", %d)'%s returns '%s'",
+    tout.api_code (), name, arg1, arg2, tout.log_code (),
+    res ? res : "<null>");
+}
+
+/*------------------------------------------------------------------------*/
+
+#define LOG_API_CALL_BEGIN(...) \
+do { \
+  if (!internal->opts.log) break; \
+  log_api_call_begin (internal, __VA_ARGS__); \
+} while (0)
+
+#define LOG_API_CALL_END(...) \
+do { \
+  if (!internal->opts.log) break; \
+  log_api_call_end (internal, __VA_ARGS__); \
+} while (0)
+
+#define LOG_API_CALL_RETURNS(...) \
+do { \
+  if (!internal->opts.log) break; \
+  log_api_call_returns (internal, __VA_ARGS__); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+#else   // end of 'then' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+
+#define LOG_API_CALL_BEGIN(...) do { } while (0)
+#define LOG_API_CALL_END(...) do { } while (0)
+#define LOG_API_CALL_RETURNS(...) do { } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif  // end of 'else' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+#ifndef NTRACING
+/*------------------------------------------------------------------------*/
+
+#define TRACE(...) \
+do { \
+  if ((this == 0)) break; \
+  if ((internal == 0)) break; \
+  LOG_API_CALL_BEGIN (__VA_ARGS__); \
+  if (!trace_api_file) break; \
+  trace_api_call (__VA_ARGS__); \
+} while (0)
+
+void Solver::trace_api_call (const char * s0) const {
+  assert (trace_api_file);
+  LOG ("TRACE %s", s0);
+  fprintf (trace_api_file, "%s\n", s0);
+  fflush (trace_api_file);
+}
+
+void Solver::trace_api_call (const char * s0, int i1) const {
+  assert (trace_api_file);
+  LOG ("TRACE %s %d", s0, i1);
+  fprintf (trace_api_file, "%s %d\n", s0, i1);
+  fflush (trace_api_file);
+}
+
+void
+Solver::trace_api_call (const char * s0, const char * s1, int i2) const {
+  assert (trace_api_file);
+  LOG ("TRACE %s %s %d", s0, s1, i2);
+  fprintf (trace_api_file, "%s %s %d\n", s0, s1, i2);
+  fflush (trace_api_file);
+}
+
+/*------------------------------------------------------------------------*/
+
+// The global 'tracing_api_calls_through_environment_variable_method' flag
+// is used to ensure that only one solver traces to a file.  Otherwise the
+// method to use an environment variable to point to the trace file is
+// bogus, since those different solver instances would all write to the same
+// file producing garbage.  A more sophisticated solution would use a
+// different mechanism to tell the solver to which file to trace to, but in
+// our experience it is quite convenient to get traces out of applications
+// which use the solver as library by just setting an environment variable
+// without requiring to change any application code.
+//
+static bool tracing_api_calls_through_environment_variable_method;
+
+/*------------------------------------------------------------------------*/
+#else // NTRACING
+/*------------------------------------------------------------------------*/
+
+#define TRACE(...) do { } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif
+/*------------------------------------------------------------------------*/
+
+Solver::Solver () {
+
+#ifndef NTRACING
+  const char * path = getenv ("CADICAL_API_TRACE");
+  if (!path) path = getenv ("CADICALAPITRACE");
+  if (path) {
+    if (tracing_api_calls_through_environment_variable_method)
+      FATAL ("can not trace API calls of two solver instances "
+        "using environment variable 'CADICAL_API_TRACE'");
+    if (!(trace_api_file = fopen (path, "w")))
+      FATAL ("failed to open file '%s' to trace API calls "
+        "using environment variable 'CADICAL_API_TRACE'", path);
+    close_trace_api_file = true;
+    tracing_api_calls_through_environment_variable_method = true;
+  } else {
+    tracing_api_calls_through_environment_variable_method = false;
+    close_trace_api_file = false;
+    trace_api_file = 0;
+  }
+#endif
+
+  _state = INITIALIZING;
+  internal = new Internal ();
+  TRACE ("init");
+  external = new External (internal);
+  STATE (CONFIGURING);
+#ifndef NTRACING
+  if (tracing_api_calls_through_environment_variable_method)
+    message ("tracing API calls to '%s'", path);
+#endif
+}
+
+Solver::~Solver () {
+
+  TRACE ("reset");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  STATE (DELETING);
+
+#ifdef LOGGING
+  //
+  // After deleting 'internal' logging does not work anymore.
+  //
+  bool logging = internal->opts.log;
+  int level = internal->level;
+  string prefix = internal->prefix;
+#endif
+
+  delete internal;
+  delete external;
+
+#ifndef NTRACING
+  if (close_trace_api_file) {
+    close_trace_api_file = false;
+    assert (trace_api_file);
+    assert (tracing_api_calls_through_environment_variable_method);
+    fclose (trace_api_file);
+    tracing_api_calls_through_environment_variable_method = false;
+  }
+#endif
+
+#ifdef LOGGING
+  //
+  // Need to log success of this API call manually.
+  //
+  if (logging) {
+    printf ("%s%sLOG %s%d%s API call %s'reset ()'%s succeeded%s\n",
+      prefix.c_str (),
+      tout.log_code (),
+      tout.emph_code (),
+      level,
+      tout.log_code (),
+      tout.api_code (),
+      tout.log_code (),
+      tout.normal_code ());
+    fflush (stdout);
+  }
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+int Solver::vars () {
+  TRACE ("vars");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  int res = external->max_var;
+  LOG_API_CALL_RETURNS ("vars", res);
+  return res;
+}
+
+void Solver::reserve (int min_max_var) {
+  TRACE ("reserve", min_max_var);
+  REQUIRE_VALID_STATE ();
+  transition_to_unknown_state ();
+  external->reset_extended ();
+  external->init (min_max_var);
+  LOG_API_CALL_END ("reserve", min_max_var);
+}
+
+/*------------------------------------------------------------------------*/
+#ifndef NTRACING
+
+void Solver::trace_api_calls (FILE * file) {
+  LOG_API_CALL_BEGIN ("trace_api_calls");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (file != 0, "invalid zero file argument");
+  REQUIRE (!tracing_api_calls_through_environment_variable_method,
+    "already tracing API calls "
+    "using environment variable 'CADICAL_API_TRACE'");
+  REQUIRE (!trace_api_file, "called twice");
+  trace_api_file = file;
+  LOG_API_CALL_END ("trace_api_calls");
+  trace_api_call ("init");
+}
+
+#endif
+/*------------------------------------------------------------------------*/
+
+bool Solver::is_valid_option (const char * name) {
+  return Options::has (name);
+}
+
+bool Solver::is_preprocessing_option (const char * name) {
+  return Options::is_preprocessing_option (name);
+}
+
+bool Solver::is_valid_long_option (const char * arg) {
+  string name;
+  int tmp;
+  return Options::parse_long_option (arg, name, tmp);
+}
+
+int Solver::get (const char * arg) {
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  return internal->opts.get (arg);
+}
+
+bool Solver::set (const char * arg, int val) {
+  TRACE ("set", arg, val);
+  REQUIRE_VALID_STATE ();
+  if (strcmp (arg, "log") &&
+      strcmp (arg, "quiet") &&
+      strcmp (arg, "report") &&
+      strcmp (arg, "verbose")) {
+    REQUIRE (state () == CONFIGURING,
+      "can only set option 'set (\"%s\", %d)' right after initialization",
+      arg, val);
+  }
+  bool res = internal->opts.set (arg, val);
+  LOG_API_CALL_END ("set", arg, val, res);
+  return res;
+}
+
+bool Solver::set_long_option (const char * arg) {
+  LOG_API_CALL_BEGIN ("set", arg);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only set option '%s' right after initialization", arg);
+  bool res;
+  if (arg[0] != '-' || arg[1] != '-') res = false;
+  else {
+    int val;
+    string name;
+    res = Options::parse_long_option (arg, name, val);
+    if (res) set (name.c_str (), val);
+  }
+  LOG_API_CALL_END ("set", arg, res);
+  return res;
+}
+
+void Solver::optimize (int arg) {
+  LOG_API_CALL_BEGIN ("optimize", arg);
+  REQUIRE_VALID_STATE ();
+  internal->opts.optimize (arg);
+  LOG_API_CALL_END ("optimize", arg);
+}
+
+bool Solver::limit (const char * arg, int val) {
+  TRACE ("limit", arg, val);
+  REQUIRE_VALID_STATE ();
+  bool res = internal->limit (arg, val);
+  LOG_API_CALL_END ("limit", arg, val, res);
+  return res;
+}
+
+bool Solver::is_valid_limit (const char * arg) {
+  return Internal::is_valid_limit (arg);
+}
+
+void Solver::prefix (const char * str) {
+  LOG_API_CALL_BEGIN ("prefix", str);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  internal->prefix = str;
+  LOG_API_CALL_END ("prefix", str);
+}
+
+bool Solver::is_valid_configuration (const char * name) {
+  return Config::has (name);
+}
+
+bool Solver::configure (const char * name) {
+  LOG_API_CALL_BEGIN ("configure", name);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only set configuration '%s' right after initialization", name);
+  bool res = Config::set (internal->opts, name);
+  LOG_API_CALL_END ("configure", name, res);
+  return res;
+}
+
+/*===== IPASIR BEGIN =====================================================*/
+
+void Solver::add (int lit) {
+  TRACE ("add", lit);
+  REQUIRE_VALID_STATE ();
+  if (lit) REQUIRE_VALID_LIT (lit);
+  transition_to_unknown_state ();
+  external->add (lit);
+  if (lit) STATE (ADDING);
+  else     STATE (UNKNOWN);
+  LOG_API_CALL_END ("add", lit);
+}
+
+void Solver::assume (int lit) {
+  TRACE ("assume", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  transition_to_unknown_state ();
+  external->assume (lit);
+  LOG_API_CALL_END ("assume", lit);
+}
+
+int Solver::lookahead () {
+  TRACE ("lookahead");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  int lit = external->lookahead ();
+  TRACE ("lookahead");
+  return lit;
+}
+
+Solver::CubesWithStatus Solver::generate_cubes (int depth, int min_depth) {
+  TRACE ("lookahead_cubes");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  auto cubes = external->generate_cubes (depth, min_depth);
+  TRACE ("lookahead_cubes");
+
+  CubesWithStatus cubes2;
+  cubes2.status = cubes.status;
+  cubes2.cubes = cubes.cubes;
+  return cubes2;
+}
+
+void Solver::reset_assumptions () {
+  TRACE ("reset_assumptions");
+  REQUIRE_VALID_STATE ();
+  transition_to_unknown_state ();
+  external->reset_assumptions ();
+  LOG_API_CALL_END ("reset_assumptions");
+}
+
+/*------------------------------------------------------------------------*/
+
+int Solver::call_external_solve_and_check_results (bool preprocess_only) {
+  transition_to_unknown_state ();
+  assert (state () & READY);
+  STATE (SOLVING);
+  const int res = external->solve (preprocess_only);
+       if (res == 10) STATE (SATISFIED);
+  else if (res == 20) STATE (UNSATISFIED);
+  else                STATE (UNKNOWN);
+#if 0 // EXPENSIVE ALTERNATIVE ASSUMPTION CHECKING
+  // This checks that the set of failed assumptions form a core using the
+  // external 'copy (...)' function to copy the solver, which can be trusted
+  // less, since it involves copying the extension stack too.  The
+  // 'External::check_assumptions_failing' is a better alternative and can
+  // be enabled by options too.  We keep this code though to have an
+  // alternative failed assumption checking available for debugging.
+  //
+  if (res == 20 && !external->assumptions.empty ()) {
+    Solver checker;
+    checker.prefix ("checker ");
+    copy (checker);
+    for (const auto & lit : external->assumptions)
+      if (failed (lit))
+        checker.add (lit), checker.add (0);
+    if (checker.solve () != 20)
+      FATAL ("copying assumption checker failed");
+  }
+#endif
+  if (!res) external->reset_assumptions ();
+  return res;
+}
+
+int Solver::solve () {
+  TRACE ("solve");
+  REQUIRE_READY_STATE ();
+  const int res = call_external_solve_and_check_results (false);
+  LOG_API_CALL_RETURNS ("solve", res);
+  return res;
+}
+
+int Solver::simplify (int rounds) {
+  TRACE ("simplify", rounds);
+  REQUIRE_READY_STATE ();
+  REQUIRE (rounds >= 0,
+    "negative number of simplification rounds '%d'", rounds);
+  internal->limit ("preprocessing", rounds);
+  const int res = call_external_solve_and_check_results (true);
+  LOG_API_CALL_RETURNS ("simplify", rounds, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Solver::val (int lit) {
+  TRACE ("val", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (state () == SATISFIED,
+    "can only get value in satisfied state");
+  int res = external->ival (lit);
+  LOG_API_CALL_RETURNS ("val", lit, res);
+  return res;
+}
+
+bool Solver::failed (int lit) {
+  TRACE ("failed", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (state () == UNSATISFIED,
+    "can only get failed assumptions in unsatisfied state");
+  bool res = external->failed (lit);
+  LOG_API_CALL_RETURNS ("failed", lit, res);
+  return res;
+}
+
+int Solver::fixed (int lit) const {
+  TRACE ("fixed", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  int res = external->fixed (lit);
+  LOG_API_CALL_RETURNS ("fixed", lit, res);
+  return res;
+}
+
+void Solver::phase (int lit) {
+  TRACE ("phase", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->phase (lit);
+  LOG_API_CALL_END ("phase", lit);
+}
+
+void Solver::unphase (int lit) {
+  TRACE ("unphase", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->unphase (lit);
+  LOG_API_CALL_END ("unphase", lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::terminate () {
+  LOG_API_CALL_BEGIN ("terminate");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  external->terminate ();
+  LOG_API_CALL_END ("terminate");
+}
+
+void Solver::connect_terminator (Terminator * terminator) {
+  LOG_API_CALL_BEGIN ("connect_terminator");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (terminator, "can not connect zero terminator");
+#ifdef LOGGING
+  if (external->terminator)
+    LOG ("connecting new terminator (disconnecting previous one)");
+  else
+    LOG ("connecting new terminator (no previous one)");
+#endif
+  external->terminator = terminator;
+  LOG_API_CALL_END ("connect_terminator");
+}
+
+void Solver::disconnect_terminator () {
+  LOG_API_CALL_BEGIN ("disconnect_terminator");
+  REQUIRE_VALID_STATE ();
+#ifdef LOGGING
+    if (external->terminator)
+      LOG ("disconnecting previous terminator");
+    else
+      LOG ("ignoring to disconnect terminator (no previous one)");
+#endif
+  external->terminator = 0;
+  LOG_API_CALL_END ("disconnect_terminator");
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::connect_learner (Learner * learner) {
+  LOG_API_CALL_BEGIN ("connect_learner");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (learner, "can not connect zero learner");
+#ifdef LOGGING
+  if (external->learner)
+    LOG ("connecting new learner (disconnecting previous one)");
+  else
+    LOG ("connecting new learner (no previous one)");
+#endif
+  external->learner = learner;
+  LOG_API_CALL_END ("connect_learner");
+}
+
+void Solver::disconnect_learner () {
+  LOG_API_CALL_BEGIN ("disconnect_learner");
+  REQUIRE_VALID_STATE ();
+#ifdef LOGGING
+    if (external->learner)
+      LOG ("disconnecting previous learner");
+    else
+      LOG ("ignoring to disconnect learner (no previous one)");
+#endif
+  external->learner = 0;
+  LOG_API_CALL_END ("disconnect_learner");
+}
+
+/*===== IPASIR END =======================================================*/
+
+int Solver::active () const {
+  TRACE ("active");
+  REQUIRE_VALID_STATE ();
+  int res = internal->active ();
+  LOG_API_CALL_RETURNS ("active", res);
+  return res;
+}
+
+int64_t Solver::redundant () const {
+  TRACE ("redundant");
+  REQUIRE_VALID_STATE ();
+  int64_t res = internal->redundant ();
+  LOG_API_CALL_RETURNS ("redundant", res);
+  return res;
+}
+
+int64_t Solver::irredundant () const {
+  TRACE ("irredundant");
+  REQUIRE_VALID_STATE ();
+  int64_t res = internal->irredundant ();
+  LOG_API_CALL_RETURNS ("irredundant", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::freeze (int lit) {
+  TRACE ("freeze", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->freeze (lit);
+  LOG_API_CALL_END ("freeze", lit);
+}
+
+void Solver::melt (int lit) {
+  TRACE ("melt", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (external->frozen (lit),
+    "can not melt completely melted literal '%d'", lit);
+  external->melt (lit);
+  LOG_API_CALL_END ("melt", lit);
+}
+
+bool Solver::frozen (int lit) const {
+  TRACE ("frozen", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  bool res = external->frozen (lit);
+  LOG_API_CALL_RETURNS ("frozen", lit, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Solver::trace_proof (FILE * external_file, const char * name) {
+  LOG_API_CALL_BEGIN ("trace_proof", name);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only start proof tracing to '%s' right after initialization",
+    name);
+  REQUIRE (!internal->tracer, "already tracing proof");
+  File * internal_file = File::write (internal, external_file, name);
+  assert (internal_file);
+  internal->trace (internal_file);
+  LOG_API_CALL_RETURNS ("trace_proof", name, true);
+  return true;
+}
+
+bool Solver::trace_proof (const char * path) {
+  LOG_API_CALL_BEGIN ("trace_proof", path);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only start proof tracing to '%s' right after initialization",
+    path);
+  REQUIRE (!internal->tracer, "already tracing proof");
+  File * internal_file = File::write (internal, path);
+  bool res = (internal_file != 0);
+  internal->trace (internal_file);
+  LOG_API_CALL_RETURNS ("trace_proof", path, res);
+  return res;
+}
+
+void Solver::flush_proof_trace () {
+  LOG_API_CALL_BEGIN ("flush_proof_trace");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (internal->tracer, "proof is not traced");
+  REQUIRE (!internal->tracer->closed (), "proof trace already closed");
+  internal->flush_trace ();
+  LOG_API_CALL_END ("flush_proof_trace");
+}
+
+void Solver::close_proof_trace () {
+  LOG_API_CALL_BEGIN ("close_proof_trace");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (internal->tracer, "proof is not traced");
+  REQUIRE (!internal->tracer->closed (), "proof trace already closed");
+  internal->close_trace ();
+  LOG_API_CALL_END ("close_proof_trace");
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::build (FILE * file, const char * prefix) {
+
+  assert (file == stdout || file == stderr);
+
+  Terminal * terminal;
+
+  if (file == stdout) terminal = &tout;
+  else if (file == stderr) terminal = &terr;
+  else terminal = 0;
+
+  const char * v = CaDiCaL::version ();
+  const char * i = identifier ();
+  const char * c = compiler ();
+  const char * b = date ();
+  const char * f = flags ();
+
+  assert (v);
+
+  fputs (prefix, file);
+  if (terminal) terminal->magenta ();
+  fputs ("Version ", file);
+  if (terminal) terminal->normal ();
+  fputs (v, file);
+  if (i) {
+    if (terminal) terminal->magenta ();
+    fputc (' ', file);
+    fputs (i, file);
+    if (terminal) terminal->normal ();
+  }
+  fputc ('\n', file);
+
+  if (c) {
+    fputs (prefix, file);
+    if (terminal) terminal->magenta ();
+    fputs (c, file);
+    if (f) {
+      fputc (' ', file);
+      fputs (f, file);
+    }
+    if (terminal) terminal->normal ();
+    fputc ('\n', file);
+  }
+
+  if (b) {
+    fputs (prefix, file);
+    if (terminal) terminal->magenta ();
+    fputs (b, file);
+    if (terminal) terminal->normal ();
+    fputc ('\n', file);
+  }
+
+  fflush (file);
+}
+
+const char * Solver::version () { return CaDiCaL::version (); }
+
+const char * Solver::signature () { return CaDiCaL::signature (); }
+
+void Solver::options () {
+  REQUIRE_VALID_STATE ();
+  internal->opts.print ();
+}
+
+void Solver::usage () { Options::usage (); }
+
+void Solver::configurations () { Config::usage (); }
+
+void Solver::statistics () {
+  if (state () == DELETING) return;
+  TRACE ("stats");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  internal->print_statistics ();
+  LOG_API_CALL_END ("stats");
+}
+
+void Solver::resources () {
+  if (state () == DELETING) return;
+  TRACE ("resources");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  internal->print_resource_usage ();
+  LOG_API_CALL_END ("resources");
+}
+
+/*------------------------------------------------------------------------*/
+
+const char * Solver::read_dimacs (File * file, int & vars, int strict,
+                                  bool * incremental, vector<int> * cubes)
+{
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only read DIMACS file right after initialization");
+  Parser * parser = new Parser (this, file, incremental, cubes);
+  const char * err = parser->parse_dimacs (vars, strict);
+  delete parser;
+  return err;
+}
+
+const char *
+Solver::read_dimacs (FILE * external_file,
+                     const char * name, int & vars, int strict) {
+  LOG_API_CALL_BEGIN ("read_dimacs", name);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only read DIMACS file right after initialization");
+  File * file = File::read (internal, external_file, name);
+  assert (file);
+  const char * err = read_dimacs (file, vars, strict);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", name, err);
+  return err;
+}
+
+const char *
+Solver::read_dimacs (const char * path, int & vars, int strict) {
+  LOG_API_CALL_BEGIN ("read_dimacs", path);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only read DIMACS file right after initialization");
+  File * file = File::read (internal, path);
+  if (!file)
+    return internal->error_message.init (
+             "failed to read DIMACS file '%s'", path);
+  const char * err = read_dimacs (file, vars, strict);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", path, err);
+  return err;
+}
+
+const char *
+Solver::read_dimacs (FILE * external_file,
+                     const char * name, int & vars, int strict,
+                     bool & incremental, vector<int> & cubes) {
+  LOG_API_CALL_BEGIN ("read_dimacs", name);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only read DIMACS file right after initialization");
+  File * file = File::read (internal, external_file, name);
+  assert (file);
+  const char * err =
+    read_dimacs (file, vars, strict, &incremental, &cubes);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", name, err);
+  return err;
+}
+
+const char *
+Solver::read_dimacs (const char * path, int & vars, int strict,
+                     bool & incremental, vector<int> & cubes) {
+  LOG_API_CALL_BEGIN ("read_dimacs", path);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+    "can only read DIMACS file right after initialization");
+  File * file = File::read (internal, path);
+  if (!file)
+    return internal->error_message.init (
+             "failed to read DIMACS file '%s'", path);
+  const char * err =
+    read_dimacs (file, vars, strict, &incremental, &cubes);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", path, err);
+  return err;
+}
+
+const char * Solver::read_solution (const char * path) {
+  LOG_API_CALL_BEGIN ("solution", path);
+  REQUIRE_VALID_STATE ();
+  File * file = File::read (internal, path);
+  if (!file) return internal->error_message.init (
+                      "failed to read solution file '%s'", path);
+  Parser * parser = new Parser (this, file, 0, 0);
+  const char * err = parser->parse_solution ();
+  delete parser;
+  delete file;
+  if (!err) external->check_assignment (&External::sol);
+  LOG_API_CALL_RETURNS ("read_solution", path, err);
+  return err;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::dump_cnf () {
+  TRACE ("dump");
+  REQUIRE_INITIALIZED ();
+  internal->dump ();
+  LOG_API_CALL_END ("dump");
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Solver::traverse_clauses (ClauseIterator & it) const {
+  LOG_API_CALL_BEGIN ("traverse_clauses");
+  REQUIRE_VALID_STATE ();
+  bool res = external->traverse_all_frozen_units_as_clauses (it) &&
+             internal->traverse_clauses (it);
+  LOG_API_CALL_RETURNS ("traverse_clauses", res);
+  return res;
+}
+
+bool Solver::traverse_witnesses_backward (WitnessIterator & it) const {
+  LOG_API_CALL_BEGIN ("traverse_witnesses_backward");
+  REQUIRE_VALID_STATE ();
+  bool res = external->traverse_all_non_frozen_units_as_witnesses (it) &&
+             external->traverse_witnesses_backward (it);
+  LOG_API_CALL_RETURNS ("traverse_witnesses_backward", res);
+  return res;
+}
+
+bool Solver::traverse_witnesses_forward (WitnessIterator & it) const {
+  LOG_API_CALL_BEGIN ("traverse_witnesses_forward");
+  REQUIRE_VALID_STATE ();
+  bool res = external->traverse_witnesses_forward (it) &&
+             external->traverse_all_non_frozen_units_as_witnesses (it);
+  LOG_API_CALL_RETURNS ("traverse_witnesses_forward", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+class ClauseCounter : public ClauseIterator {
+public:
+  int vars;
+  int64_t clauses;
+  ClauseCounter () : vars (0), clauses (0) { }
+  bool clause (const vector<int> & c) {
+    for (const auto & lit : c) {
+      assert (lit != INT_MIN);
+      int idx = abs (lit);
+      if (idx > vars) vars = idx;
+    }
+    clauses++;
+    return true;
+  }
+};
+
+class ClauseWriter : public ClauseIterator {
+  File * file;
+public:
+  ClauseWriter (File * f) : file (f) { }
+  bool clause (const vector<int> & c) {
+    for (const auto & lit : c) {
+      if (!file->put (lit)) return false;
+      if (!file->put (' ')) return false;
+    }
+    return file->put ("0\n");
+  }
+};
+
+const char * Solver::write_dimacs (const char * path, int min_max_var) {
+  LOG_API_CALL_BEGIN ("write_dimacs", path, min_max_var);
+  REQUIRE_VALID_STATE ();
+#ifndef QUIET
+  const double start = internal->time ();
+#endif
+  internal->restore_clauses ();
+  ClauseCounter counter;
+  (void) traverse_clauses (counter);
+  LOG ("found maximal variable %d and %" PRId64 " clauses",
+    counter.vars, counter.clauses);
+  File * file = File::write (internal, path);
+  const char * res = 0;
+  if (file) {
+    int actual_max_vars = max (min_max_var, counter.vars);
+    MSG ("writing %s'p cnf %d %" PRId64 "'%s header",
+      tout.green_code (), actual_max_vars, counter.clauses,
+      tout.normal_code ());
+    file->put ("p cnf ");
+    file->put (actual_max_vars);
+    file->put (' ');
+    file->put (counter.clauses);
+    file->put ('\n');
+    ClauseWriter writer (file);
+    if (!traverse_clauses (writer))
+      res = internal->error_message.init (
+              "writing to DIMACS file '%s' failed", path);
+    delete file;
+  } else res = internal->error_message.init (
+                 "failed to open DIMACS file '%s' for writing", path);
+#ifndef QUIET
+  if (!res) {
+    const double end = internal->time ();
+    MSG ("wrote %" PRId64 " clauses in %.2f seconds %s time",
+      counter.clauses, end - start,
+      internal->opts.realtime ? "real" : "process");
+  }
+#endif
+  LOG_API_CALL_RETURNS ("write_dimacs", path, min_max_var, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+struct WitnessWriter : public WitnessIterator {
+  File * file;
+  int64_t witnesses;
+  WitnessWriter (File * f) : file (f), witnesses (0) { }
+  bool write (const vector<int> & a) {
+    for (const auto & lit : a) {
+      if (!file->put (lit)) return false;
+      if (!file->put (' ')) return false;
+    }
+    return file->put ('0');
+  }
+  bool witness (const vector<int> & c, const vector<int> & w) {
+    if (!write (c)) return false;
+    if (!file->put (' ')) return false;
+    if (!write (w)) return false;
+    if (!file->put ('\n')) return false;
+    witnesses++;
+    return true;
+  }
+};
+
+const char * Solver::write_extension (const char * path) {
+  LOG_API_CALL_BEGIN ("write_extension", path);
+  REQUIRE_VALID_STATE ();
+  const char * res = 0;
+#ifndef QUIET
+  const double start = internal->time ();
+#endif
+  File * file = File::write (internal, path);
+  WitnessWriter writer (file);
+  if (file) {
+    if (!traverse_witnesses_backward (writer))
+      res = internal->error_message.init (
+              "writing to DIMACS file '%s' failed", path);
+    delete file;
+  } else res = internal->error_message.init (
+                 "failed to open extension file '%s' for writing", path);
+#ifndef QUIET
+  if (!res) {
+    const double end = internal->time ();
+    MSG ("wrote %" PRId64 " witnesses in %.2f seconds %s time",
+      writer.witnesses, end - start,
+      internal->opts.realtime ? "real" : "process");
+  }
+#endif
+  LOG_API_CALL_RETURNS ("write_extension", path, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+struct ClauseCopier : public ClauseIterator {
+  Solver & dst;
+public:
+  ClauseCopier (Solver & d) : dst (d) { }
+  bool clause (const vector<int> & c) {
+    for (const auto & lit : c)
+      dst.add (lit);
+    dst.add (0);
+    return true;
+  }
+};
+
+struct WitnessCopier : public WitnessIterator {
+  External * dst;
+public:
+  WitnessCopier (External * d) : dst (d) { }
+  bool witness (const vector<int> & c, const vector<int> & w) {
+    dst->push_external_clause_and_witness_on_extension_stack (c, w);
+    return true;
+  }
+};
+
+void Solver::copy (Solver & other) const {
+  REQUIRE_READY_STATE ();
+  REQUIRE (other.state () & CONFIGURING,
+    "target solver already modified");
+  internal->opts.copy (other.internal->opts);
+  ClauseCopier clause_copier (other);
+  traverse_clauses (clause_copier);
+  WitnessCopier witness_copier (other.external);
+  traverse_witnesses_forward (witness_copier);
+  external->copy_flags (*other.external);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::section (const char * title) {
+  if (state () == DELETING) return;
+#ifdef QUIET
+  (void) title;
+#endif
+  REQUIRE_INITIALIZED ();
+  SECTION (title);
+}
+
+void Solver::message (const char * fmt, ...) {
+  if (state () == DELETING) return;
+#ifdef QUIET
+  (void) fmt;
+#else
+  REQUIRE_INITIALIZED ();
+  va_list ap;
+  va_start (ap, fmt);
+  internal->vmessage (fmt, ap);
+  va_end (ap);
+#endif
+}
+
+void Solver::message () {
+  if (state () == DELETING) return;
+  REQUIRE_INITIALIZED ();
+#ifndef QUIET
+  internal->message ();
+#endif
+}
+
+void Solver::verbose (int level, const char * fmt, ...) {
+  if (state () == DELETING) return;
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+#ifdef QUIET
+  (void) level;
+  (void) fmt;
+#else
+  va_list ap;
+  va_start (ap, fmt);
+  internal->vverbose (level, fmt, ap);
+  va_end (ap);
+#endif
+}
+
+void Solver::error (const char * fmt, ...) {
+  if (state () == DELETING) return;
+  REQUIRE_INITIALIZED ();
+  va_list ap;
+  va_start (ap, fmt);
+  internal->verror (fmt, ap);
+  va_end (ap);
+}
+
+}
diff --git a/hCaD_V2/src/stats.cpp b/hCaD_V2/src/stats.cpp
new file mode 100644
index 0000000..ac38240
--- /dev/null
+++ b/hCaD_V2/src/stats.cpp
@@ -0,0 +1,307 @@
+// vim: set tw=300: set VIM text width to 300 characters for this file.
+
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+Stats::Stats () {
+  memset (this, 0, sizeof *this);
+  time.real = absolute_real_time ();
+  time.process = absolute_process_time ();
+  walk.minimum = LONG_MAX;
+}
+
+/*------------------------------------------------------------------------*/
+
+#define PRT(FMT,...) \
+do { \
+  if (FMT[0] == ' ' && !all) break; \
+  MSG (FMT, __VA_ARGS__); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+void Stats::print (Internal * internal) {
+
+#ifdef QUIET
+  (void) internal;
+#else
+
+  Stats & stats = internal->stats;
+
+  int all = internal->opts.verbose > 0;
+#ifdef LOGGING
+  if (internal->opts.log) all = true;
+#endif // ifdef LOGGING
+
+  if (internal->opts.profile) internal->print_profile ();
+
+  double t = internal->solve_time ();
+
+  int64_t propagations = 0;
+  propagations += stats.propagations.cover;
+  propagations += stats.propagations.probe;
+  propagations += stats.propagations.search;
+  propagations += stats.propagations.transred;
+  propagations += stats.propagations.vivify;
+  propagations += stats.propagations.walk;
+
+  int64_t vivified = stats.vivifysubs + stats.vivifystrs;
+
+  size_t extendbytes = internal->external->extension.size ();
+  extendbytes *= sizeof (int);
+
+  SECTION ("statistics");
+
+  if (all || stats.blocked) {
+  PRT ("blocked:         %15" PRId64 "   %10.2f %%  of irredundant clauses", stats.blocked, percent (stats.blocked, stats.added.irredundant));
+  PRT ("  blockings:     %15" PRId64 "   %10.2f    internal", stats.blockings, relative (stats.conflicts, stats.blockings));
+  PRT ("  candidates:    %15" PRId64 "   %10.2f    per blocking ", stats.blockcands, relative (stats.blockcands, stats.blockings));
+  PRT ("  blockres:      %15" PRId64 "   %10.2f    per candidate", stats.blockres, relative (stats.blockres, stats.blockcands));
+  PRT ("  pure:          %15" PRId64 "   %10.2f %%  of all variables", stats.all.pure, percent (stats.all.pure, stats.vars));
+  PRT ("  pureclauses:   %15" PRId64 "   %10.2f    per pure literal", stats.blockpured, relative (stats.blockpured, stats.all.pure));
+  }
+  if (all || stats.chrono)
+  PRT ("chronological:   %15" PRId64 "   %10.2f %%  of conflicts", stats.chrono, percent (stats.chrono, stats.conflicts));
+  if (all)
+  PRT ("compacts:        %15" PRId64 "   %10.2f    interval", stats.compacts, relative (stats.conflicts, stats.compacts));
+  if (all || stats.conflicts) {
+  PRT ("conflicts:       %15" PRId64 "   %10.2f    per second", stats.conflicts, relative (stats.conflicts, t));
+  PRT ("  backtracked:   %15" PRId64 "   %10.2f %%  of conflicts", stats.backtracks, percent (stats.backtracks, stats.conflicts));
+  }
+  if (all || stats.conditioned) {
+  PRT ("conditioned:     %15" PRId64 "   %10.2f %%  of irredundant clauses", stats.conditioned, percent (stats.conditioned, stats.added.irredundant));
+  PRT ("  conditionings: %15" PRId64 "   %10.2f    interval", stats.conditionings, relative (stats.conflicts, stats.conditionings));
+  PRT ("  condcands:     %15" PRId64 "   %10.2f    candidate clauses", stats.condcands, relative (stats.condcands, stats.conditionings));
+  PRT ("  condassinit:   %17.1f  %9.2f %%  initial assigned", relative (stats.condassinit, stats.conditionings), percent (stats.condassinit, stats.condassvars));
+  PRT ("  condcondinit:  %17.1f  %9.2f %%  initial condition", relative (stats.condcondinit, stats.conditionings), percent (stats.condcondinit, stats.condassinit));
+  PRT ("  condautinit:   %17.1f  %9.2f %%  initial autarky", relative (stats.condautinit, stats.conditionings), percent (stats.condautinit, stats.condassinit));
+  PRT ("  condassrem:    %17.1f  %9.2f %%  final assigned", relative (stats.condassrem, stats.conditioned), percent (stats.condassrem, stats.condassirem));
+  PRT ("  condcondrem:   %19.3f  %7.2f %%  final conditional", relative (stats.condcondrem, stats.conditioned), percent (stats.condcondrem, stats.condassrem));
+  PRT ("  condautrem:    %19.3f  %7.2f %%  final autarky", relative (stats.condautrem, stats.conditioned), percent (stats.condautrem, stats.condassrem));
+  PRT ("  condprops:     %15" PRId64 "   %10.2f    per candidate", stats.condprops, relative (stats.condprops, stats.condcands));
+  }
+  if (all || stats.cover.total) {
+  PRT ("covered:         %15" PRId64 "   %10.2f %%  of irredundant clauses", stats.cover.total, percent (stats.cover.total, stats.added.irredundant));
+  PRT ("  coverings:     %15" PRId64 "   %10.2f    interval", stats.cover.count, relative (stats.conflicts, stats.cover.count));
+  PRT ("  asymmetric:    %15" PRId64 "   %10.2f %%  of covered clauses", stats.cover.asymmetric, percent (stats.cover.asymmetric, stats.cover.total));
+  PRT ("  blocked:       %15" PRId64 "   %10.2f %%  of covered clauses", stats.cover.blocked, percent (stats.cover.blocked, stats.cover.total));
+  }
+  if (all || stats.decisions) {
+  PRT ("decisions:       %15" PRId64 "   %10.2f    per second", stats.decisions, relative (stats.decisions, t));
+  PRT ("  searched:      %15" PRId64 "   %10.2f    per decision", stats.searched, relative (stats.searched, stats.decisions));
+  }
+  if (all || stats.all.eliminated) {
+  PRT ("eliminated:      %15" PRId64 "   %10.2f %%  of all variables", stats.all.eliminated, percent (stats.all.eliminated, stats.vars));
+  PRT ("  elimphases:    %15" PRId64 "   %10.2f    interval", stats.elimphases, relative (stats.conflicts, stats.elimphases));
+  PRT ("  elimrounds:    %15" PRId64 "   %10.2f    per phase", stats.elimrounds, relative (stats.elimrounds, stats.elimphases));
+  PRT ("  elimtried:     %15" PRId64 "   %10.2f %%  eliminated", stats.elimtried, percent (stats.all.eliminated, stats.elimtried));
+  PRT ("  elimgates:     %15" PRId64 "   %10.2f %%  gates per tried", stats.elimgates, percent (stats.elimgates, stats.elimtried));
+  PRT ("  elimequivs:    %15" PRId64 "   %10.2f %%  equivalence gates", stats.elimequivs, percent (stats.elimequivs, stats.elimgates));
+  PRT ("  elimands:      %15" PRId64 "   %10.2f %%  and gates", stats.elimands, percent (stats.elimands, stats.elimgates));
+  PRT ("  elimites:      %15" PRId64 "   %10.2f %%  if-then-else gates", stats.elimites, percent (stats.elimites, stats.elimgates));
+  PRT ("  elimxors:      %15" PRId64 "   %10.2f %%  xor gates", stats.elimxors, percent (stats.elimxors, stats.elimgates));
+  PRT ("  elimsubst:     %15" PRId64 "   %10.2f %%  substituted", stats.elimsubst, percent (stats.elimsubst, stats.all.eliminated));
+  PRT ("  elimres:       %15" PRId64 "   %10.2f    per eliminated", stats.elimres, relative (stats.elimres, stats.all.eliminated));
+  PRT ("  elimrestried:  %15" PRId64 "   %10.2f %%  per resolution", stats.elimrestried, percent (stats.elimrestried, stats.elimres));
+  }
+  if (all || stats.all.fixed) {
+  PRT ("fixed:           %15" PRId64 "   %10.2f %%  of all variables", stats.all.fixed, percent (stats.all.fixed, stats.vars));
+  PRT ("  failed:        %15" PRId64 "   %10.2f %%  of all variables", stats.failed, percent (stats.failed, stats.vars));
+  PRT ("  probefailed:   %15" PRId64 "   %10.2f %%  per failed", stats.probefailed, percent (stats.probefailed, stats.failed));
+  PRT ("  transredunits: %15" PRId64 "   %10.2f %%  per failed", stats.transredunits, percent (stats.transredunits, stats.failed));
+  PRT ("  probingphases: %15" PRId64 "   %10.2f    interval", stats.probingphases, relative (stats.conflicts, stats.probingphases));
+  PRT ("  probesuccess:  %15" PRId64 "   %10.2f %%  phases", stats.probesuccess, percent (stats.probesuccess, stats.probingphases));
+  PRT ("  probingrounds: %15" PRId64 "   %10.2f    per phase", stats.probingrounds, relative (stats.probingrounds, stats.probingphases));
+  PRT ("  probed:        %15" PRId64 "   %10.2f    per failed", stats.probed, relative (stats.probed, stats.failed));
+  PRT ("  hbrs:          %15" PRId64 "   %10.2f    per probed", stats.hbrs, relative (stats.hbrs, stats.probed));
+  PRT ("  hbrsizes:      %15" PRId64 "   %10.2f    per hbr", stats.hbrsizes, relative (stats.hbrsizes, stats.hbrs));
+  PRT ("  hbreds:        %15" PRId64 "   %10.2f %%  per hbr", stats.hbreds, percent (stats.hbreds, stats.hbrs));
+  PRT ("  hbrsubs:       %15" PRId64 "   %10.2f %%  per hbr", stats.hbrsubs, percent (stats.hbrsubs, stats.hbrs));
+  }
+  PRT ("  units:         %15" PRId64 "   %10.2f    interval", stats.units, relative (stats.conflicts, stats.units));
+  PRT ("  binaries:      %15" PRId64 "   %10.2f    interval", stats.binaries, relative (stats.conflicts, stats.binaries));
+  if (all || stats.flush.learned) {
+  PRT ("flushed:         %15" PRId64 "   %10.2f %%  per conflict", stats.flush.learned, percent (stats.flush.learned, stats.conflicts));
+  PRT ("  hyper:         %15" PRId64 "   %10.2f %%  per conflict", stats.flush.hyper, relative (stats.flush.hyper, stats.conflicts));
+  PRT ("  flushings:     %15" PRId64 "   %10.2f    interval", stats.flush.count, relative (stats.conflicts, stats.flush.count));
+  }
+  if (all || stats.instantiated) {
+  PRT ("instantiated:    %15" PRId64 "   %10.2f %%  of tried", stats.instantiated, percent (stats.instantiated, stats.instried));
+  PRT ("  instrounds:    %15" PRId64 "   %10.2f %%  of elimrounds", stats.instrounds, percent (stats.instrounds, stats.elimrounds));
+  }
+  if (all || stats.conflicts) {
+  PRT ("learned:         %15" PRId64 "   %10.2f %%  per conflict", stats.learned.clauses, percent (stats.learned.clauses, stats.conflicts));
+  PRT ("  bumped:        %15" PRId64 "   %10.2f    per learned", stats.bumped, relative (stats.bumped, stats.learned.clauses));
+  PRT ("  recomputed:    %15" PRId64 "   %10.2f %%  per learned", stats.recomputed, percent (stats.recomputed, stats.learned.clauses));
+  PRT ("  promoted1:     %15" PRId64 "   %10.2f %%  per learned", stats.promoted1, percent (stats.promoted1, stats.learned.clauses));
+  PRT ("  promoted2:     %15" PRId64 "   %10.2f %%  per learned", stats.promoted2, percent (stats.promoted2, stats.learned.clauses));
+  PRT ("  improvedglue:  %15" PRId64 "   %10.2f %%  per learned", stats.improvedglue, percent (stats.improvedglue, stats.learned.clauses));
+  }
+  if (all || stats.lucky.succeeded) {
+  PRT ("lucky:           %15" PRId64 "   %10.2f %%  of tried", stats.lucky.succeeded, percent (stats.lucky.succeeded, stats.lucky.tried));
+  PRT ("  constantzero   %15" PRId64 "   %10.2f %%  of tried", stats.lucky.constant.zero, percent (stats.lucky.constant.zero, stats.lucky.tried));
+  PRT ("  constantone    %15" PRId64 "   %10.2f %%  of tried", stats.lucky.constant.one, percent (stats.lucky.constant.one, stats.lucky.tried));
+  PRT ("  backwardone    %15" PRId64 "   %10.2f %%  of tried", stats.lucky.backward.one, percent (stats.lucky.backward.one, stats.lucky.tried));
+  PRT ("  backwardzero   %15" PRId64 "   %10.2f %%  of tried", stats.lucky.backward.zero, percent (stats.lucky.backward.zero, stats.lucky.tried));
+  PRT ("  forwardone     %15" PRId64 "   %10.2f %%  of tried", stats.lucky.forward.one, percent (stats.lucky.forward.one, stats.lucky.tried));
+  PRT ("  forwardzero    %15" PRId64 "   %10.2f %%  of tried", stats.lucky.forward.zero, percent (stats.lucky.forward.zero, stats.lucky.tried));
+  PRT ("  positivehorn   %15" PRId64 "   %10.2f %%  of tried", stats.lucky.horn.positive, percent (stats.lucky.horn.positive, stats.lucky.tried));
+  PRT ("  negativehorn   %15" PRId64 "   %10.2f %%  of tried", stats.lucky.horn.negative, percent (stats.lucky.horn.negative, stats.lucky.tried));
+  }
+  PRT ("  extendbytes:   %15zd   %10.2f    bytes and MB", extendbytes, extendbytes/(double)(1l<<20));
+  if (all || stats.learned.clauses)
+  PRT ("learned_lits:    %15" PRId64 "   %10.2f %%  learned literals", stats.learned.literals, percent (stats.learned.literals, stats.learned.literals));
+  PRT ("minimized:       %15" PRId64 "   %10.2f %%  learned literals", stats.minimized, percent (stats.minimized, stats.learned.literals));
+  PRT ("shrunken:        %15" PRId64 "   %10.2f %%  learned literals", stats.shrunken, percent(stats.shrunken, stats.learned.literals));
+  PRT ("minishrunken:    %15" PRId64 "   %10.2f %%  learned literals", stats.minishrunken, percent(stats.minishrunken, stats.learned.literals));
+
+  PRT ("propagations:    %15" PRId64 "   %10.2f M  per second", propagations, relative (propagations/1e6, t));
+  PRT ("  coverprops:    %15" PRId64 "   %10.2f %%  of propagations", stats.propagations.cover, percent (stats.propagations.cover, propagations));
+  PRT ("  probeprops:    %15" PRId64 "   %10.2f %%  of propagations", stats.propagations.probe, percent (stats.propagations.probe, propagations));
+  PRT ("  searchprops:   %15" PRId64 "   %10.2f %%  of propagations", stats.propagations.search, percent (stats.propagations.search, propagations));
+  PRT ("  transredprops: %15" PRId64 "   %10.2f %%  of propagations", stats.propagations.transred, percent (stats.propagations.transred, propagations));
+  PRT ("  vivifyprops:   %15" PRId64 "   %10.2f %%  of propagations", stats.propagations.vivify, percent (stats.propagations.vivify, propagations));
+  PRT ("  walkprops:     %15" PRId64 "   %10.2f %%  of propagations", stats.propagations.walk, percent (stats.propagations.walk, propagations));
+  if (all || stats.reactivated) {
+  PRT ("reactivated:     %15" PRId64 "   %10.2f %%  of all variables", stats.reactivated, percent (stats.reactivated, stats.vars));
+  }
+  if (all || stats.reduced) {
+  PRT ("reduced:         %15" PRId64 "   %10.2f %%  per conflict", stats.reduced, percent (stats.reduced, stats.conflicts));
+  PRT ("  reductions:    %15" PRId64 "   %10.2f    interval", stats.reductions, relative (stats.conflicts, stats.reductions));
+  PRT ("  collections:   %15" PRId64 "   %10.2f    interval", stats.collections, relative (stats.conflicts, stats.collections));
+  }
+  if (all || stats.rephased.total) {
+  PRT ("rephased:        %15" PRId64 "   %10.2f    interval", stats.rephased.total, relative (stats.conflicts, stats.rephased.total));
+  PRT ("  rephasedbest:  %15" PRId64 "   %10.2f %%  rephased best", stats.rephased.best, percent (stats.rephased.best, stats.rephased.total));
+  PRT ("  rephasedflip:  %15" PRId64 "   %10.2f %%  rephased flipping", stats.rephased.flipped, percent (stats.rephased.flipped, stats.rephased.total));
+  PRT ("  rephasedinv:   %15" PRId64 "   %10.2f %%  rephased inverted", stats.rephased.inverted, percent (stats.rephased.inverted, stats.rephased.total));
+  PRT ("  rephasedorig:  %15" PRId64 "   %10.2f %%  rephased original", stats.rephased.original, percent (stats.rephased.original, stats.rephased.total));
+  PRT ("  rephasedrand:  %15" PRId64 "   %10.2f %%  rephased random", stats.rephased.random, percent (stats.rephased.random, stats.rephased.total));
+  PRT ("  rephasedwalk:  %15" PRId64 "   %10.2f %%  rephased walk", stats.rephased.walk, percent (stats.rephased.walk, stats.rephased.total));
+  }
+  if (all)
+  PRT ("rescored:        %15" PRId64 "   %10.2f    interval", stats.rescored, relative (stats.conflicts, stats.rescored));
+  if (all || stats.restarts) {
+  PRT ("restarts:        %15" PRId64 "   %10.2f    interval", stats.restarts, relative (stats.conflicts, stats.restarts));
+  PRT ("  reused:        %15" PRId64 "   %10.2f %%  per restart", stats.reused, percent (stats.reused, stats.restarts));
+  PRT ("  reusedlevels:  %15" PRId64 "   %10.2f %%  per restart levels", stats.reusedlevels, percent (stats.reusedlevels, stats.restartlevels));
+  }
+  if (all || stats.restored) {
+  PRT ("restored:        %15" PRId64 "   %10.2f %%  per weakened", stats.restored, percent (stats.restored, stats.weakened));
+  PRT ("  restorations:  %15" PRId64 "   %10.2f %%  per extension", stats.restorations, percent (stats.restorations, stats.extensions));
+  PRT ("  literals:      %15" PRId64 "   %10.2f    per restored clause", stats.restoredlits, relative (stats.restoredlits, stats.restored));
+  }
+  if (all || stats.stabphases) {
+  PRT ("stabilizing:     %15" PRId64 "   %10.2f %%  of conflicts", stats.stabphases, percent (stats.stabconflicts, stats.conflicts));
+  PRT ("  restartstab:   %15" PRId64 "   %10.2f %%  of all restarts", stats.restartstable, percent (stats.restartstable, stats.restarts));
+  PRT ("  reusedstab:    %15" PRId64 "   %10.2f %%  per stable restarts", stats.reusedstable, percent (stats.reusedstable, stats.restartstable));
+  }
+  if (all || stats.all.substituted) {
+  PRT ("substituted:     %15" PRId64 "   %10.2f %%  of all variables", stats.all.substituted, percent (stats.all.substituted, stats.vars));
+  PRT ("  decompositions:%15" PRId64 "   %10.2f    per phase", stats.decompositions, relative (stats.decompositions, stats.probingphases));
+  }
+  if (all || stats.subsumed) {
+  PRT ("subsumed:        %15" PRId64 "   %10.2f %%  of all clauses", stats.subsumed, percent (stats.subsumed, stats.added.total));
+  PRT ("  subsumephases: %15" PRId64 "   %10.2f    interval", stats.subsumephases, relative (stats.conflicts, stats.subsumephases));
+  PRT ("  subsumerounds: %15" PRId64 "   %10.2f    per phase", stats.subsumerounds, relative (stats.subsumerounds, stats.subsumephases));
+  PRT ("  deduplicated:  %15" PRId64 "   %10.2f %%  per subsumed", stats.deduplicated, percent (stats.deduplicated, stats.subsumed));
+  PRT ("  transreds:     %15" PRId64 "   %10.2f    interval", stats.transreds, relative (stats.conflicts, stats.transreds));
+  PRT ("  transitive:    %15" PRId64 "   %10.2f %%  per subsumed", stats.transitive, percent (stats.transitive, stats.subsumed));
+  PRT ("  subirr:        %15" PRId64 "   %10.2f %%  of subsumed", stats.subirr, percent (stats.subirr, stats.subsumed));
+  PRT ("  subred:        %15" PRId64 "   %10.2f %%  of subsumed", stats.subred, percent (stats.subred, stats.subsumed));
+  PRT ("  subtried:      %15" PRId64 "   %10.2f    tried per subsumed", stats.subtried, relative (stats.subtried, stats.subsumed));
+  PRT ("  subchecks:     %15" PRId64 "   %10.2f    per tried", stats.subchecks, relative (stats.subchecks, stats.subtried));
+  PRT ("  subchecks2:    %15" PRId64 "   %10.2f %%  per subcheck", stats.subchecks2, percent (stats.subchecks2, stats.subchecks));
+  PRT ("  elimotfsub:    %15" PRId64 "   %10.2f %%  of subsumed", stats.elimotfsub, percent (stats.elimotfsub, stats.subsumed));
+  PRT ("  elimbwsub:     %15" PRId64 "   %10.2f %%  of subsumed", stats.elimbwsub, percent (stats.elimbwsub, stats.subsumed));
+  PRT ("  eagersub:      %15" PRId64 "   %10.2f %%  of subsumed", stats.eagersub, percent (stats.eagersub, stats.subsumed));
+  PRT ("  eagertried:    %15" PRId64 "   %10.2f    tried per eagersub", stats.eagertried, relative (stats.eagertried, stats.eagersub));
+  }
+  if (all || stats.strengthened) {
+  PRT ("strengthened:    %15" PRId64 "   %10.2f %%  of all clauses", stats.strengthened, percent (stats.strengthened, stats.added.total));
+  PRT ("  elimotfstr:    %15" PRId64 "   %10.2f %%  of strengthened", stats.elimotfstr, percent (stats.elimotfstr, stats.strengthened));
+  PRT ("  elimbwstr:     %15" PRId64 "   %10.2f %%  of strengthened", stats.elimbwstr, percent (stats.elimbwstr, stats.strengthened));
+  }
+  if (all || stats.htrs) {
+  PRT ("ternary:         %15" PRId64 "   %10.2f %%  of resolved", stats.htrs, percent (stats.htrs, stats.ternres));
+  PRT ("  phases:        %15" PRId64 "   %10.2f    interval", stats.ternary, relative (stats.conflicts, stats.ternary));
+  PRT ("  htr3:          %15" PRId64 "   %10.2f %%  ternary hyper ternres", stats.htrs3, percent (stats.htrs3, stats.htrs));
+  PRT ("  htr2:          %15" PRId64 "   %10.2f %%  binary hyper ternres", stats.htrs2, percent (stats.htrs2, stats.htrs));
+  }
+  if (all || vivified) {
+  PRT ("vivified:        %15" PRId64 "   %10.2f %%  of all clauses", vivified, percent (vivified, stats.added.total));
+  PRT ("  vivifications: %15" PRId64 "   %10.2f    interval", stats.vivifications, relative (stats.conflicts, stats.vivifications));
+  PRT ("  vivifychecks:  %15" PRId64 "   %10.2f %%  per conflict", stats.vivifychecks, percent (stats.vivifychecks, stats.conflicts));
+  PRT ("  vivifysched:   %15" PRId64 "   %10.2f %%  checks per scheduled", stats.vivifysched, percent (stats.vivifychecks, stats.vivifysched));
+  PRT ("  vivifyunits:   %15" PRId64 "   %10.2f %%  per vivify check", stats.vivifyunits, percent (stats.vivifyunits, stats.vivifychecks));
+  PRT ("  vivifysubs:    %15" PRId64 "   %10.2f %%  per subsumed", stats.vivifysubs, percent (stats.vivifysubs, stats.subsumed));
+  PRT ("  vivifystrs:    %15" PRId64 "   %10.2f %%  per strengthened", stats.vivifystrs, percent (stats.vivifystrs, stats.strengthened));
+  PRT ("  vivifystrirr:  %15" PRId64 "   %10.2f %%  per vivifystrs", stats.vivifystrirr, percent (stats.vivifystrirr, stats.vivifystrs));
+  PRT ("  vivifystred1:  %15" PRId64 "   %10.2f %%  per vivifystrs", stats.vivifystred1, percent (stats.vivifystred1, stats.vivifystrs));
+  PRT ("  vivifystred2:  %15" PRId64 "   %10.2f %%  per vivifystrs", stats.vivifystred2, percent (stats.vivifystred2, stats.vivifystrs));
+  PRT ("  vivifystred3:  %15" PRId64 "   %10.2f %%  per vivifystrs", stats.vivifystred3, percent (stats.vivifystred3, stats.vivifystrs));
+  PRT ("  vivifydecs:    %15" PRId64 "   %10.2f    per checks", stats.vivifydecs, relative (stats.vivifydecs, stats.vivifychecks));
+  PRT ("  vivifyreused:  %15" PRId64 "   %10.2f %%  per decision", stats.vivifyreused, percent (stats.vivifyreused, stats.vivifydecs));
+  }
+  if (all || stats.walk.count) {
+  PRT ("walked:          %15" PRId64 "   %10.2f    interval", stats.walk.count, relative (stats.conflicts, stats.walk.count));
+#ifndef QUIET
+  if (internal->profiles.walk.value > 0)
+  PRT ("  flips:         %15" PRId64 "   %10.2f M  per second", stats.walk.flips, relative (1e-6*stats.walk.flips, internal->profiles.walk.value));
+  else
+#endif
+  PRT ("  flips:         %15" PRId64 "   %10.2f    per walk", stats.walk.flips, relative (stats.walk.flips, stats.walk.count));
+  if (stats.walk.minimum < LONG_MAX)
+  PRT ("  minimum:       %15" PRId64 "   %10.2f %%  clauses", stats.walk.minimum, percent (stats.walk.minimum, stats.added.irredundant));
+  PRT ("  broken:        %15" PRId64 "   %10.2f    per flip", stats.walk.broken, relative (stats.walk.broken, stats.walk.flips));
+  }
+  if (all || stats.weakened) {
+  PRT ("weakened:        %15" PRId64 "   %10.2f    average size", stats.weakened, relative (stats.weakenedlen, stats.weakened));
+  PRT ("  extensions:    %15" PRId64 "   %10.2f    interval", stats.extensions, relative (stats.conflicts, stats.extensions));
+  PRT ("  flipped:       %15" PRId64 "   %10.2f    per weakened", stats.extended, relative (stats.extended, stats.weakened));
+  }
+
+  LINE ();
+  MSG ("%sseconds are measured in %s time for solving%s",
+    tout.magenta_code (),
+      internal->opts.realtime ? "real" : "process",
+    tout.normal_code ());
+
+#endif // ifndef QUIET
+}
+
+void Internal::print_resource_usage () {
+#ifndef QUIET
+  SECTION ("resources");
+  uint64_t m = maximum_resident_set_size ();
+  MSG ("total process time since initialization: %12.2f    seconds", internal->process_time ());
+  MSG ("total real time since initialization:    %12.2f    seconds", internal->real_time ());
+  MSG ("maximum resident set size of process:    %12.2f    MB", m/(double)(1l<<20));
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+void Checker::print_stats () {
+
+  if (!stats.added && !stats.deleted) return;
+
+  SECTION ("checker statistics");
+
+  MSG ("checks:          %15" PRId64 "", stats.checks);
+  MSG ("assumptions:     %15" PRId64 "   %10.2f    per check", stats.assumptions, relative (stats.assumptions, stats.checks));
+  MSG ("propagations:    %15" PRId64 "   %10.2f    per check", stats.propagations, relative (stats.propagations, stats.checks));
+  MSG ("original:        %15" PRId64 "   %10.2f %%  of all clauses", stats.original, percent (stats.original, stats.added));
+  MSG ("derived:         %15" PRId64 "   %10.2f %%  of all clauses", stats.derived, percent (stats.derived, stats.added));
+  MSG ("deleted:         %15" PRId64 "   %10.2f %%  of all clauses", stats.deleted, percent (stats.deleted, stats.added));
+  MSG ("insertions:      %15" PRId64 "   %10.2f %%  of all clauses", stats.insertions, percent (stats.insertions, stats.added));
+  MSG ("collections:     %15" PRId64 "   %10.2f    deleted per collection", stats.collections, relative (stats.collections, stats.deleted));
+  MSG ("collisions:      %15" PRId64 "   %10.2f    per search", stats.collisions, relative (stats.collisions, stats.searches));
+  MSG ("searches:        %15" PRId64 "", stats.searches);
+  MSG ("units:           %15" PRId64 "", stats.units);
+}
+
+}
diff --git a/hCaD_V2/src/stats.hpp b/hCaD_V2/src/stats.hpp
new file mode 100644
index 0000000..753c458
--- /dev/null
+++ b/hCaD_V2/src/stats.hpp
@@ -0,0 +1,231 @@
+#ifndef _stats_hpp_INCLUDED
+#define _stats_hpp_INCLUDED
+
+#include <cstdlib>
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct Stats {
+
+  Internal * internal;
+
+  int64_t vars;         // internal initialized variables
+
+  int64_t conflicts;    // generated conflicts in 'propagate'
+  int64_t decisions;    // number of decisions in 'decide'
+
+  struct {
+    int64_t cover;      // propagated during covered clause elimination
+    int64_t instantiate;// propagated during variable instantiation
+    int64_t probe;      // propagated during probing
+    int64_t search;     // propagated literals during search
+    int64_t transred;   // propagated during transitive reduction
+    int64_t vivify;     // propagated during vivification
+    int64_t walk;       // propagated during local search
+  } propagations;
+
+  int64_t condassinit;  // initial assigned literals
+  int64_t condassirem;  // initial assigned literals for blocked
+  int64_t condassrem;   // remaining assigned literals for blocked
+  int64_t condassvars;  // sum of active variables at initial assignment
+  int64_t condautinit;  // initial literals in autarky part
+  int64_t condautrem;   // remaining literals in autarky part for blocked
+  int64_t condcands;    // globally blocked candidate clauses
+  int64_t condcondinit; // initial literals in conditional part
+  int64_t condcondrem;  // remaining literals in conditional part for blocked
+  int64_t conditioned;  // globally blocked clauses eliminated
+  int64_t conditionings;// globally blocked clause eliminations
+  int64_t condprops;    // propagated unassigned literals
+
+  struct {
+    int64_t block;      // block marked literals
+    int64_t elim;       // elim marked variables
+    int64_t subsume;    // subsume marked variables
+    int64_t ternary;    // ternary marked variables
+  } mark;
+
+  struct {
+    int64_t total;
+    int64_t redundant;
+    int64_t irredundant;
+  } current, added;  // Clauses.
+
+  struct { double process, real; } time;
+
+  struct {
+    int64_t count;      // number of covered clause elimination rounds
+    int64_t asymmetric; // number of asymmetric tautologies in CCE
+    int64_t blocked;    // number of blocked covered tautologies
+    int64_t total;      // total number of eliminated clauses
+  } cover;
+
+  struct {
+    int64_t tried;
+    int64_t succeeded;
+    struct { int64_t one, zero; } constant, forward, backward;
+    struct { int64_t positive, negative; } horn;
+  } lucky;
+
+  struct {
+    int64_t total;      // total number of happened rephases
+    int64_t best;       // how often reset to best phases
+    int64_t flipped;    // how often reset phases by flipping
+    int64_t inverted;   // how often reset to inverted phases
+    int64_t original;   // how often reset to original phases
+    int64_t random;     // how often randomly reset phases
+    int64_t walk;       // phases improved through random walked
+  } rephased;
+
+  struct {
+    int64_t count;
+    int64_t broken;
+    int64_t flips;
+    int64_t minimum;
+  } walk;
+
+  struct {
+    int64_t count;      // flushings of learned clauses counter
+    int64_t learned;    // flushed learned clauses
+    int64_t hyper;      // flushed hyper binary/ternary clauses
+  } flush;
+
+  int64_t compacts;     // number of compactifications
+  int64_t shuffled;     // shuffled queues and scores
+  int64_t restarts;     // actual number of happened restarts
+  int64_t restartlevels;// levels at restart
+  int64_t restartstable;// actual number of happened restarts
+  int64_t stabphases;   // number of stabilization phases
+  int64_t stabconflicts;// number of search conflicts during stabilizing
+  int64_t rescored;     // number of times scores were rescored
+  int64_t reused;       // number of reused trails
+  int64_t reusedlevels; // reused levels at restart
+  int64_t reusedstable; // number of reused trails during stabilizing
+  int64_t sections;     // 'section' counter
+  int64_t chrono;       // chronological backtracks
+  int64_t backtracks;   // number of backtracks
+  int64_t improvedglue; // improved glue during bumping
+  int64_t promoted1;    // promoted clauses to tier one
+  int64_t promoted2;    // promoted clauses to tier two
+  int64_t bumped;       // seen and bumped variables in 'analyze'
+  int64_t recomputed;   // recomputed glues 'recompute_glue'
+  int64_t searched;     // searched decisions in 'decide'
+  int64_t reductions;   // 'reduce' counter
+  int64_t reduced;      // number of reduced clauses
+  int64_t collected;    // number of collected bytes
+  int64_t collections;  // number of garbage collections
+  int64_t hbrs;         // hyper binary resolvents
+  int64_t hbrsizes;     // sum of hyper resolved base clauses
+  int64_t hbreds;       // redundant hyper binary resolvents
+  int64_t hbrsubs;      // subsuming hyper binary resolvents
+  int64_t instried;     // number of tried instantiations
+  int64_t instantiated; // number of successful instantiations
+  int64_t instrounds;   // number of instantiation rounds
+  int64_t subsumed;     // number of subsumed clauses
+  int64_t deduplicated; // number of removed duplicated binary clauses
+  int64_t deduplications;//number of deduplication phases
+  int64_t strengthened; // number of strengthened clauses
+  int64_t elimotfstr;   // number of on-the-fly strengthened during elimination
+  int64_t subirr;       // number of subsumed irredundant clauses
+  int64_t subred;       // number of subsumed redundant clauses
+  int64_t subtried;     // number of tried subsumptions
+  int64_t subchecks;    // number of pair-wise subsumption checks
+  int64_t subchecks2;   // same but restricted to binary clauses
+  int64_t elimotfsub;   // number of on-the-fly subsumed during elimination
+  int64_t subsumerounds;// number of subsumption rounds
+  int64_t subsumephases;// number of scheduled subsumption phases
+  int64_t eagertried;   // number of traversed eager subsumed candidates
+  int64_t eagersub;     // number of eagerly subsumed recently learned clauses
+  int64_t elimres;      // number of resolved clauses in BVE
+  int64_t elimrestried; // number of tried resolved clauses in BVE
+  int64_t elimrounds;   // number of elimination rounds
+  int64_t elimphases;   // number of scheduled elimination phases
+  int64_t elimcompleted;// number complete elimination procedures
+  int64_t elimtried;    // number of variable elimination attempts
+  int64_t elimsubst;    // number of eliminations through substitutions
+  int64_t elimgates;    // number of gates found during elimination
+  int64_t elimequivs;   // number of equivalences found during elimination
+  int64_t elimands;     // number of AND gates found during elimination
+  int64_t elimites;     // number of ITE gates found during elimination
+  int64_t elimxors;     // number of XOR gates found during elimination
+  int64_t elimbwsub;    // number of eager backward subsumed clauses
+  int64_t elimbwstr;    // number of eager backward strengthened clauses
+  int64_t ternary;      // number of ternary resolution phases
+  int64_t ternres;      // number of ternary resolutions
+  int64_t htrs;         // number of hyper ternary resolvents
+  int64_t htrs2;        // number of binary hyper ternary resolvents
+  int64_t htrs3;        // number of ternary hyper ternary resolvents
+  int64_t decompositions; // number of SCC + ELS
+  int64_t vivifications;  // number of vivifications
+  int64_t vivifychecks; // checked clauses during vivification
+  int64_t vivifydecs;   // vivification decisions
+  int64_t vivifyreused; // reused vivification decisions
+  int64_t vivifysched;  // scheduled clauses for vivification
+  int64_t vivifysubs;   // subsumed clauses during vivification
+  int64_t vivifystrs;   // strengthened clauses during vivification
+  int64_t vivifystrirr; // strengthened irredundant clause
+  int64_t vivifystred1; // strengthened redundant clause (1)
+  int64_t vivifystred2; // strengthened redundant clause (2)
+  int64_t vivifystred3; // strengthened redundant clause (3)
+  int64_t vivifyunits;  // units during vivification
+  int64_t transreds;
+  int64_t transitive;
+  struct {
+    int64_t literals;
+    int64_t clauses;
+  } learned;
+  int64_t minimized; // minimized literals
+  int64_t shrunken;  // shrunken literals
+  int64_t minishrunken;  // shrunken during minimization literals
+
+  int64_t irrbytes;     // bytes of irredundant clauses
+  int64_t garbage;      // bytes current irredundant garbage clauses
+  int64_t units;        // learned unit clauses
+  int64_t binaries;     // learned binary clauses
+  int64_t probingphases;// number of scheduled probing phases
+  int64_t probingrounds;// number of probing rounds
+  int64_t probesuccess; // number successful probing phases
+  int64_t probed;       // number of probed literals
+  int64_t failed;       // number of failed literals
+  int64_t hyperunary;   // hyper unary resolved unit clauses
+  int64_t probefailed;  // failed literals from probing
+  int64_t transredunits;// units derived in transitive reduction
+  int64_t blockings;    // number of blocked clause eliminations
+  int64_t blocked;      // number of actually blocked clauses
+  int64_t blockres;     // number of resolutions during blocking
+  int64_t blockcands;   // number of clause / pivot pairs tried
+  int64_t blockpured;   // number of clauses blocked through pure literals
+  int64_t blockpurelits;// number of pure literals
+  int64_t extensions;   // number of extended witnesses
+  int64_t extended;     // number of flipped literals during extension
+  int64_t weakened;     // number of clauses pushed to extension stack
+  int64_t weakenedlen;  // lengths of weakened clauses
+  int64_t restorations; // number of restore calls
+  int64_t restored;     // number of restored clauses
+  int64_t reactivated;  // number of reactivated clauses
+  int64_t restoredlits; // number of restored literals
+
+  int64_t preprocessings;
+
+  struct {
+    int64_t fixed;       // number of top level assigned variables
+    int64_t eliminated;  // number of eliminated variables
+    int64_t substituted; // number of substituted variables
+    int64_t pure;        // number of pure literals
+  } all, now;
+
+  int64_t unused;        // number of unused variables
+  int64_t active;        // number of active variables
+  int64_t inactive;      // number of inactive variables
+
+  Stats ();
+
+  void print (Internal *);
+};
+
+/*------------------------------------------------------------------------*/
+
+}
+
+#endif
diff --git a/hCaD_V2/src/subsume.cpp b/hCaD_V2/src/subsume.cpp
new file mode 100644
index 0000000..f1aadaa
--- /dev/null
+++ b/hCaD_V2/src/subsume.cpp
@@ -0,0 +1,612 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This file implements a global forward subsumption algorithm, which is run
+// frequently during search.  It works both on original (irredundant)
+// clauses and on 'sticky' learned clauses which are likely to be kept.
+// This is abstracted away in the 'likely_to_be_kept_clause' function, which
+// implicitly relies on 'opts.reducetier1lgue' (glucose level of clauses
+// which are not reduced) as well as dynamically determined size and glucose
+// level ('lim.keptglue' and 'lim.keptsize') of clauses kept in 'reduce'.
+//
+// Note, that 'forward' means that the clause from which the subsumption
+// check is started is checked for being subsumed by other (smaller or equal
+// size) clauses.  Since 'vivification' is an extended version of subsume,
+// more powerful, but also slower, we schedule 'vivify' right after
+// 'subsume', which in contrast to 'subsume' is not run until to completion.
+//
+// This implementation is inspired by Bayardo's SDM'11 analysis of our
+// subsumption algorithm in our SATeLite preprocessor in the context of
+// finding extremal sets in data mining and his suggested improvements.
+
+// Our original subsumption algorithm in 'Quantor' and 'SATeLite' (and in
+// MiniSAT and descendants) is based on backward subsumption.  It uses the
+// observation that only the occurrence list of one literal of a clause has
+// to be traversed in order to find all potential clauses which are subsumed
+// by the candidate.  Thus the literal with the smallest number of
+// occurrences is used.  However, that scheme requires to connect all
+// literals of surviving clauses, while forward algorithms only need to
+// connect one literal. On the other hand forward checking requires to
+// traverse the occurrence lists of all literals of the candidate clause to
+// find subsuming clauses.  During connecting the single literal (similar to
+// the one-watch scheme by Lintao Zhang) one can connect a literal with a
+// minimal number of occurrence so far, which implicitly also reduces future
+// occurrence list traversal time.
+
+// Also the actual subsumption check is cheaper since during backward
+// checking the short subsuming candidate clause is marked and all the
+// literals in the larger subsume candidate clauses have to be traversed,
+// while for our forward approach the long subsumed candidate clause is only
+// marked once, while the literals of the shorter subsuming clauses have to
+// be checked.  We also use a fixed special more cache friendly data
+// structure for binary clauses, to avoid traversing them directly.
+
+// In our forward scheme it is still possible to skip occurrence lists of
+// literals which were not added since the last subsumption round, since
+// only those can contain subsuming candidates.  Actually, clauses which
+// contain at least one literal, which was not added since the last
+// subsumption round do not have to be connected at all, even though they
+// might still be subsumed them self.
+
+// Bayardo suggests to sort the literals in clauses and perform some kind of
+// partial merge-sort, while we mark literals, but do sort literals during
+// connecting a clause w.r.t. the number of occurrences, in order to find
+// literals which do not occur in the subsumed candidate fast with high
+// probability (less occurring literals have a higher chance).
+
+bool Internal::subsuming () {
+
+  if (!opts.subsume && !opts.vivify) return false;
+  if (!preprocessing && !opts.inprocessing) return false;
+  if (preprocessing) assert (lim.preprocessing);
+
+  // Only perform global subsumption checking immediately after a clause
+  // reduction happened where the overall allocated memory is small and we
+  // got a limit on the number of kept clause in terms of size and glue.
+  //
+  if (opts.reduce &&
+      stats.conflicts != last.reduce.conflicts) return false;
+
+  if (stats.conflicts < lim.subsume) return false;
+
+  return true;
+}
+
+// This is the actual subsumption and strengthening check.  We assume that
+// all the literals of the candidate clause to be subsumed or strengthened
+// are marked, so we only have to check that all the literals of the
+// argument clause 'subsuming', which is checked for subsuming the candidate
+// clause 'subsumed', has all its literals marked (in the correct phase).
+// If exactly one is in the opposite phase we can still strengthen the
+// candidate clause by this single literal which occurs in opposite phase.
+//
+// The result is INT_MIN if all literals are marked and thus the candidate
+// clause can be subsumed.  It is zero if neither subsumption nor
+// strengthening is possible.  Otherwise the candidate clause can be
+// strengthened and as a result the negation of the literal which can be
+// removed is returned.
+
+inline int Internal::subsume_check (Clause * subsuming, Clause * subsumed)
+{
+#ifdef NDEBUG
+  (void) subsumed;
+#endif
+  // Only use 'subsumed' for these following assertion checks.  Otherwise we
+  // only require that 'subsumed' has all its literals marked.
+  //
+  assert (!subsumed->garbage);
+  assert (!subsuming->garbage);
+  assert (subsuming != subsumed);
+  assert (subsuming->size <= subsumed->size);
+
+  stats.subchecks++;
+  if (subsuming->size == 2) stats.subchecks2++;
+
+  int flipped = 0, prev = 0;
+  bool failed = false;
+  const auto eoc = subsuming->end ();
+  for (auto i = subsuming->begin (); !failed && i != eoc; i++) {
+    int lit = *i;
+    *i = prev;
+    prev = lit;
+    const int tmp = marked (lit);
+    if (!tmp) failed = true;
+    else if (tmp > 0) continue;
+    else if (flipped) failed = true;
+    else flipped = lit;
+  }
+  assert (prev);
+  assert (!subsuming->literals[0]);
+  subsuming->literals[0] = prev;
+  if (failed) return 0;
+
+  if (!flipped) return INT_MIN;                   // subsumed!!
+  else if (!opts.subsumestr) return 0;
+  else return flipped;                            // strengthen!!
+}
+
+/*------------------------------------------------------------------------*/
+
+// Candidate clause 'subsumed' is subsumed by 'subsuming'.
+
+inline void
+Internal::subsume_clause (Clause * subsuming, Clause * subsumed) {
+  stats.subsumed++;
+  assert (subsuming->size <= subsumed->size);
+  LOG (subsumed, "subsumed");
+  if (subsumed->redundant) stats.subred++; else stats.subirr++;
+  mark_garbage (subsumed);
+  if (subsumed->redundant || !subsuming->redundant) return;
+  LOG ("turning redundant subsuming clause into irredundant clause");
+  subsuming->redundant = false;
+  stats.current.irredundant++;
+  stats.added.irredundant++;
+  stats.irrbytes += subsuming->bytes ();
+  assert (stats.current.redundant > 0);
+  stats.current.redundant--;
+  assert (stats.added.redundant > 0);
+  stats.added.redundant--;
+  // ... and keep 'stats.added.total'.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Candidate clause 'c' is strengthened by removing 'lit'.
+
+void Internal::strengthen_clause (Clause * c, int lit) {
+  stats.strengthened++;
+  assert (c->size > 2);
+  LOG (c, "removing %d in", lit);
+  if (proof) proof->strengthen_clause (c, lit);
+  if (!c->redundant) mark_removed (lit);
+  auto new_end = remove (c->begin (), c->end (), lit);
+  assert (new_end + 1 == c->end ()), (void) new_end;
+  (void) shrink_clause (c, c->size - 1);
+  c->used = true;
+  LOG (c, "strengthened");
+  external->check_shrunken_clause (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find clauses connected in the occurrence lists 'occs' which subsume the
+// candidate clause 'c' given as first argument.  If this is the case the
+// clause is subsumed and the result is positive.   If the clause was
+// strengthened the result is negative.  Otherwise the candidate clause
+// can not be subsumed nor strengthened and zero is returned.
+
+inline int
+Internal::try_to_subsume_clause (Clause * c, vector<Clause *> & shrunken) {
+
+  stats.subtried++;
+  assert (!level);
+  LOG (c, "trying to subsume");
+
+  mark (c);     // signed!
+
+  Clause dummy; // Communicate binary subsuming clause.
+
+  Clause * d = 0;
+  int flipped = 0;
+
+  for (const auto & lit : *c) {
+
+    // Only clauses which have a variable which has recently been added are
+    // checked for being subsumed.  The idea is that all these newly added
+    // clauses are candidates for subsubming the clause.  Then we also only
+    // need to check occurrences of these variables.  The occurrence lists
+    // of other literal do not have to be checked.
+    //
+    if (!flags (lit).subsume) continue;
+
+    for (int sign = -1; !d && sign <= 1; sign += 2) {
+
+      // First we check against all binary clauses.  The other literals of
+      // all binary clauses of 'sign*lit' are stored in one consecutive
+      // array, which is way faster than storing clause pointers and
+      // dereferencing them.  Since this binary clause array is also not
+      // shrunken, we also can bail out earlier if subsumption or
+      // strengthening is determined.  In both cases the (self-)subsuming
+      // clause is stored in 'd', which makes it nonzero and forces
+      // aborting both the outer and inner loop.  If the binary clause can
+      // strengthen the candidate clause 'c' (through self-subsuming
+      // resolution), then 'filled' is set to the literal which can be
+      // removed in 'c', otherwise to 'INT_MIN' which is a non-valid
+      // literal.
+      //
+      for (const auto & other : bins (sign*lit) ) {
+        const int tmp = marked (other);
+        if (!tmp) continue;
+        if (tmp < 0 && sign < 0) continue;
+        if (tmp < 0) {
+          if (sign < 0) continue;               // tautological resolvent
+          dummy.literals[0] = lit;
+          dummy.literals[1] = other;
+          flipped = other;
+        } else {
+          dummy.literals[0] = sign*lit;
+          dummy.literals[1] = other;
+          flipped = (sign < 0) ? -lit : INT_MIN;
+        }
+        dummy.redundant = false;
+        dummy.size = 2;
+        d = &dummy;
+        break;
+      }
+
+      if (d) break;
+
+      // In this second loop we check for larger than binary clauses to
+      // subsume or strengthen the candidate clause.   This is more costly,
+      // and needs a call to 'subsume_check'.  Otherwise the same contract
+      // as above for communicating 'subsumption' or 'strengthening' to the
+      // code after the loop is used.
+      //
+      const Occs & os = occs (sign * lit);
+      for (const auto & e : os) {
+        assert (!e->garbage);                   // sanity check
+        if (e->garbage) continue;               // defensive: not needed
+        flipped = subsume_check (e, c);
+        if (!flipped) continue;
+        d = e;                                  // leave also outer loop
+        break;
+      }
+    }
+
+    if (d) break;
+  }
+
+  unmark (c);
+
+  if (flipped == INT_MIN) {
+    LOG (d, "subsuming");
+    subsume_clause (d, c);
+    return 1;
+  }
+
+  if (flipped) {
+    LOG (d, "strengthening");
+    strengthen_clause (c, -flipped);
+    assert (likely_to_be_kept_clause (c));
+    shrunken.push_back (c);
+    return -1;
+  }
+
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Sorting the scheduled clauses is way faster if we compute and save the
+// clause size in the schedule to avoid pointer access to clauses during
+// sorting.  This slightly increases the schedule size though.
+
+struct ClauseSize {
+  size_t size;
+  Clause * clause;
+  ClauseSize (int s, Clause * c) : size (s), clause (c) { }
+  ClauseSize () { }
+};
+
+struct smaller_clause_size_rank {
+  typedef size_t Type;
+  Type operator () (const ClauseSize & a) { return a.size; }
+};
+
+/*------------------------------------------------------------------------*/
+
+struct subsume_less_noccs {
+  Internal * internal;
+  subsume_less_noccs (Internal * i) : internal (i) { }
+  bool operator () (int a, int b) {
+    const signed char u = internal->val (a), v = internal->val (b);
+    if (!u && v) return true;
+    if (u && !v) return false;
+    const int64_t m = internal->noccs (a), n = internal ->noccs (b);
+    if (m < n) return true;
+    if (m > n) return false;
+    return abs (a) < abs (b);
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Usually called from 'subsume' below if 'subsuming' triggered it.  Then
+// the idea is to subsume both redundant and irredundant clauses. It is also
+// called in the elimination loop in 'elim' in which case we focus on
+// irredundant clauses only to help bounded variable elimination.  The
+// function returns true of an irredundant clause was removed or
+// strengthened, which might then in the second usage scenario trigger new
+// variable eliminations.
+
+bool Internal::subsume_round () {
+
+  if (!opts.subsume) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
+  if (!stats.current.redundant && !stats.current.irredundant) return false;
+
+  START_SIMPLIFIER (subsume, SUBSUME);
+  stats.subsumerounds++;
+
+  int64_t check_limit;
+  if (opts.subsumelimited) {
+    int64_t delta = stats.propagations.search;
+    delta *= 1e-3 * opts.subsumereleff;
+    if (delta < opts.subsumemineff) delta = opts.subsumemineff;
+    if (delta > opts.subsumemaxeff) delta = opts.subsumemaxeff;
+    delta = max (delta, (int64_t) 2l * active ());
+
+    PHASE ("subsume-round", stats.subsumerounds,
+      "limit of %" PRId64 " subsumption checks", delta);
+
+    check_limit = stats.subchecks + delta;
+  } else {
+    PHASE ("subsume-round", stats.subsumerounds,
+      "unlimited subsumption checks");
+    check_limit = LONG_MAX;
+  }
+
+  int old_marked_candidate_variables_for_elimination = stats.mark.elim;
+
+  assert (!level);
+
+  // Allocate schedule and occurrence lists.
+  //
+  vector<ClauseSize> schedule;
+  init_noccs ();
+
+  // Determine candidate clauses and sort them by size.
+  //
+  int64_t left_over_from_last_subsumption_round = 0;
+
+  for (auto c : clauses) {
+
+    if (c->garbage) continue;
+    if (c->size > opts.subsumeclslim) continue;
+    if (!likely_to_be_kept_clause (c)) continue;
+
+    bool fixed = false;
+    int subsume = 0;
+    for (const auto & lit : *c)
+      if (val (lit)) fixed = true;
+      else if (flags (lit).subsume) subsume++;
+
+    // If the clause contains a root level assigned (fixed) literal we will
+    // not work on it.  This simplifies the code substantially since we do
+    // not have to care about assignments at all.  Strengthening becomes
+    // much simpler too.
+    //
+    if (fixed) {
+      LOG (c, "skipping (fixed literal)");
+      continue;
+    }
+
+    // Further, if less than two variables in the clause were added since
+    // the last subsumption round, the clause is ignored too.
+    //
+    if (subsume < 2) {
+      LOG (c, "skipping (only %d added literals)", subsume);
+      continue;
+    }
+
+    if (c->subsume) left_over_from_last_subsumption_round++;
+    schedule.push_back (ClauseSize (c->size, c));
+    for (const auto & lit : *c)
+      noccs (lit)++;
+  }
+  shrink_vector (schedule);
+
+  // Smaller clauses are checked and connected first.
+  //
+  rsort (schedule.begin (), schedule.end (), smaller_clause_size_rank ());
+
+  if (!left_over_from_last_subsumption_round)
+    for (auto cs : schedule)
+      if (cs.clause->size > 2)
+        cs.clause->subsume = true;
+
+#ifndef QUIET
+  int64_t scheduled = schedule.size ();
+  int64_t total = stats.current.irredundant + stats.current.redundant;
+  PHASE ("subsume-round", stats.subsumerounds,
+    "scheduled %" PRId64 " clauses %.0f%% out of %" PRId64 " clauses",
+    scheduled, percent (scheduled, total), total);
+#endif
+
+  // Now go over the scheduled clauses in the order of increasing size and
+  // try to forward subsume and strengthen them. Forward subsumption tries
+  // to find smaller or same size clauses which subsume or might strengthen
+  // the candidate.  After the candidate has been processed connect one
+  // of its literals (with smallest number of occurrences at this point) in
+  // a one-watched scheme.
+
+  int64_t subsumed = 0, strengthened = 0, checked = 0;
+
+  vector<Clause *> shrunken;
+  init_occs ();
+  init_bins ();
+
+  for (const auto & s : schedule) {
+
+    if (terminated_asynchronously ()) break;
+    if (stats.subchecks >= check_limit) break;
+
+    Clause * c = s.clause;
+    assert (!c->garbage);
+
+    checked++;
+
+    // First try to subsume or strengthen this candidate clause.  For binary
+    // clauses this could be done much faster by hashing and is costly due
+    // to a usually large number of binary clauses.  There is further the
+    // issue, that strengthening binary clauses (through double
+    // self-subsuming resolution) would produce units, which needs much more
+    // care. In the same (lazy) spirit we also ignore clauses with fixed
+    // literals (false or true).
+    //
+    if (c->size > 2 && c->subsume) {
+      c->subsume = false;
+      const int tmp = try_to_subsume_clause (c, shrunken);
+      if (tmp > 0) { subsumed++; continue; }
+      if (tmp < 0) strengthened++;
+    }
+
+    // If not subsumed connect smallest occurring literal, where occurring
+    // means the number of times it was used to connect (as a one-watch) a
+    // previous smaller or equal sized clause.  This minimizes the length of
+    // the occurrence lists traversed during 'try_to_subsume_clause'. Also
+    // note that this number is usually way smaller than the number of
+    // occurrences computed before and stored in 'noccs'.
+    //
+    int minlit = 0;
+    int64_t minoccs = 0;
+    size_t minsize = 0;
+    bool subsume = true;
+    bool binary = (c->size == 2 && !c->redundant);
+
+    for (const auto & lit : *c) {
+
+      if (!flags (lit).subsume) subsume = false;
+      const size_t size = binary ? bins (lit).size () : occs (lit).size ();
+      if (minlit && minsize <= size) continue;
+      const int64_t tmp = noccs (lit);
+      if (minlit && minsize == size && tmp <= minoccs) continue;
+      minlit = lit, minsize = size, minoccs = tmp;
+    }
+
+    // If there is a variable in a clause different from is not 'subsume'
+    // (has been added since the last subsumption round), then this clause
+    // can not serve to strengthen or subsume another clause, since all
+    // shrunken or added clauses mark all their variables as 'subsume'.
+    //
+    if (!subsume) continue;
+
+    if (!binary) {
+
+      // If smallest occurring literal occurs too often do not connect.
+      //
+      if (minsize > (size_t) opts.subsumeocclim) continue;
+
+      LOG (c, "watching %d with %zd current and total %" PRId64 " occurrences",
+        minlit, minsize, minoccs);
+
+      occs (minlit).push_back (c);
+
+      // This sorting should give faster failures for assumption checks
+      // since the less occurring variables are put first in a clause and
+      // thus will make it more likely to be found as witness for a clause
+      // not to be subsuming.  One could in principle (see also the
+      // discussion on 'subsumption' in our 'Splatz' solver) replace marking
+      // by a kind of merge sort, as also suggested by Bayardo.  It would
+      // avoid 'marked' calls and thus might be slightly faster but could
+      // not take benefit of this sorting optimization.
+      //
+      sort (c->begin (), c->end (), subsume_less_noccs (this));
+
+    } else {
+
+      // If smallest occurring literal occurs too often do not connect.
+      //
+      if (minsize > (size_t) opts.subsumebinlim) continue;
+
+      LOG (c,
+        "watching %d with %zd current binary and total %" PRId64 " occurrences",
+        minlit, minsize, minoccs);
+
+      const int minlit_pos = (c->literals[1] == minlit);
+      const int other = c->literals[!minlit_pos];
+      bins (minlit).push_back (other);
+    }
+  }
+
+  PHASE ("subsume-round", stats.subsumerounds,
+    "subsumed %" PRId64 " and strengthened %" PRId64
+    " out of %" PRId64 " clauses %.0f%%",
+    subsumed, strengthened, scheduled,
+    percent (subsumed + strengthened, scheduled));
+
+  const int64_t remain = schedule.size () - checked;
+  const bool completed = !remain;
+
+  if (completed)
+    PHASE ("subsume-round", stats.subsumerounds,
+      "checked all %" PRId64 " scheduled clauses", checked);
+  else
+    PHASE ("subsume-round", stats.subsumerounds,
+      "checked %" PRId64 " clauses %.0f%% of scheduled (%" PRId64 " remain)",
+      checked, percent (checked, scheduled), remain);
+
+  // Release occurrence lists and schedule.
+  //
+  erase_vector (schedule);
+  reset_noccs ();
+  reset_occs ();
+  reset_bins ();
+
+  // Reset all old 'added' flags and mark variables in shrunken
+  // clauses as 'added' for the next subsumption round.
+  //
+  if (completed)
+    reset_subsume_bits ();
+
+  for (const auto & c : shrunken)
+    mark_added (c);
+  erase_vector (shrunken);
+
+  report ('s', !opts.reportall && !(subsumed + strengthened));
+
+  STOP_SIMPLIFIER (subsume, SUBSUME);
+
+  return old_marked_candidate_variables_for_elimination < stats.mark.elim;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::subsume (bool update_limits) {
+
+  stats.subsumephases++;
+
+  if (!stats.current.redundant && !stats.current.irredundant)
+    goto UPDATE_LIMITS;
+
+  if (unsat) return;
+
+  backtrack ();
+  if (!propagate ()) {
+    learn_empty_clause ();
+    return;
+  }
+
+  if (opts.subsume) {
+    reset_watches ();
+    subsume_round ();
+    init_watches ();
+    connect_watches ();
+    if (!unsat && !propagate ()) {
+      LOG ("propagation after subsume rounds results in inconsistency");
+      learn_empty_clause ();
+    }
+  }
+
+  // Schedule 'vivification' in 'subsume' as well as 'transitive reduction'.
+  //
+  if (opts.vivify) vivify ();
+  if (opts.transred) transred ();
+
+UPDATE_LIMITS:
+
+  if (!update_limits) return;
+
+  int64_t delta = scale (opts.subsumeint * (stats.subsumephases + 1));
+  lim.subsume = stats.conflicts + delta;
+
+  PHASE ("subsume-phase", stats.subsumephases,
+    "new subsume limit %" PRId64 " after %" PRId64 " conflicts",
+    lim.subsume, delta);
+}
+
+}
diff --git a/hCaD_V2/src/terminal.cpp b/hCaD_V2/src/terminal.cpp
new file mode 100644
index 0000000..86703e4
--- /dev/null
+++ b/hCaD_V2/src/terminal.cpp
@@ -0,0 +1,34 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+Terminal::Terminal (FILE * f) : file (f), reset_on_exit (false) {
+  assert (file);
+  int fd = fileno (f);
+  assert (fd == 1 || fd == 2);
+  use_colors = connected = isatty (fd);
+}
+
+void Terminal::force_colors () { use_colors = connected = true;}
+void Terminal::force_no_colors () { use_colors = false; }
+void Terminal::force_reset_on_exit () { reset_on_exit = true; }
+
+void Terminal::reset () {
+  if (!connected) return;
+  erase_until_end_of_line ();
+  cursor (true);
+  normal ();
+  fflush (file);
+}
+
+void Terminal::disable () {
+  reset ();
+  connected = use_colors = false;
+}
+
+Terminal::~Terminal () { if (reset_on_exit) reset (); }
+
+Terminal tout (stdout);
+Terminal terr (stderr);
+
+}
diff --git a/hCaD_V2/src/terminal.hpp b/hCaD_V2/src/terminal.hpp
new file mode 100644
index 0000000..62c3755
--- /dev/null
+++ b/hCaD_V2/src/terminal.hpp
@@ -0,0 +1,93 @@
+#ifndef _terminal_hpp_INCLUDED
+#define _terminal_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+class Terminal {
+
+  FILE * file;          // 'stdout' or 'stderr'
+  bool connected;       // Connected to terminal.
+  bool use_colors;      // Use colors.
+  bool reset_on_exit;   // Reset on exit.
+
+  void escape () {
+    assert (connected);
+    fputs ("\033[", file);
+  }
+
+  void color (int color, bool bright) {
+    if (!use_colors) return;
+    assert (connected);
+    escape ();
+    fputc (bright ? '1' : '0', file);
+    fprintf (file, ";%dm", color);
+    fflush (file);
+  }
+
+  void code (const char * str) {
+    if (!connected) return;
+    escape ();
+    fputs (str, file);
+    fflush (file);
+  }
+
+public:
+
+  Terminal (FILE * file);
+  ~Terminal ();
+
+  void disable ();              // Assume disconnected in any case.
+  void force_colors ();
+  void force_no_colors ();
+  void force_reset_on_exit ();
+
+  bool colors () { return use_colors; }
+
+  operator bool () const { return connected; }
+
+  void red (bool bright = false)     { color (31, bright); }
+  void green (bool bright = false)   { color (32, bright); }
+  void yellow (bool bright = false)  { color (33, bright); }
+  void blue (bool bright = false)    { color (34, bright); }
+  void magenta (bool bright = false) { color (35, bright); }
+  void black (bool bright = false)   { color (90, bright); }
+  void cyan (bool bright = false)    { color (96, bright); }
+
+  void bold () { code ("1m"); }
+  void normal () { code ("0m"); }
+  void inverse () { code ("7m"); }
+  void underline () { code ("4m"); }
+
+#define MODIFY(CODE) (use_colors ? "\033[" CODE "m" : "")
+
+  const char * bright_magenta_code () { return MODIFY ("1;35"); }
+  const char * magenta_code ()        { return MODIFY ("0;35"); }
+  const char * blue_code ()           { return MODIFY ("0;34"); }
+  const char * bright_blue_code ()    { return MODIFY ("1;34"); }
+  const char * yellow_code ()         { return MODIFY ("0;33"); }
+  const char * bright_yellow_code ()  { return MODIFY ("1;33"); }
+  const char * green_code ()          { return MODIFY ("0;32"); }
+  const char * red_code ()            { return MODIFY ("0;31"); }
+  const char * cyan_code ()           { return MODIFY ("0;96"); }
+  const char * bright_red_code ()     { return MODIFY ("1;31"); }
+  const char * normal_code ()         { return MODIFY ("0"   ); }
+  const char * bold_code ()           { return MODIFY ("1"   ); }
+
+  void cursor (bool on) { code (on ? "?25h" : "?25l"); }
+
+  void erase_until_end_of_line () { code ("K"); }
+
+  void erase_line_if_connected_otherwise_new_line () {
+    if (connected) code ("1G");
+    else fputc ('\n', file), fflush (file);
+  }
+
+  void reset ();
+};
+
+extern Terminal tout;   // Terminal of 'stdout' (file descriptor '1')
+extern Terminal terr;   // Terminal of 'stderr' (file descriptor '2')
+
+}
+
+#endif
diff --git a/hCaD_V2/src/ternary.cpp b/hCaD_V2/src/ternary.cpp
new file mode 100644
index 0000000..fdca428
--- /dev/null
+++ b/hCaD_V2/src/ternary.cpp
@@ -0,0 +1,365 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This procedure can be used to produce all possible hyper ternary
+// resolvents from ternary clauses.  In contrast to hyper binary resolution
+// we would only try to produce ternary clauses from ternary clauses, i.e.,
+// do not consider quaternary clauses as antecedents.  Of course if a binary
+// clause is generated we keep it too.  In any case we have to make sure
+// though that we do not add clauses which are already in the formula or are
+// subsumed by a binary clause in the formula.  This procedure simulates
+// structural hashing for multiplexer (if-then-else) and binary XOR gates in
+// combination with equivalent literal substitution ('decompose') if run
+// until to completion (which in the current implementation is too costly
+// though and would need to be interleaved more eagerly with equivalent
+// literal substitution).  For more information see our CPAIOR'13 paper.
+
+/*------------------------------------------------------------------------*/
+
+// Check whether a binary clause consisting of the permutation of the given
+// literals already exists.
+
+bool
+Internal::ternary_find_binary_clause (int a, int b) {
+  assert (occurring ());
+  assert (active (a));
+  assert (active (b));
+  size_t s = occs (a).size ();
+  size_t t = occs (b).size ();
+  int lit = s < t ? a : b;
+  if (opts.ternaryocclim < (int) occs (lit).size ()) return true;
+  for (const auto & c : occs (lit)) {
+    if (c->size != 2) continue;
+    const int * lits = c->literals;
+    if (lits[0] == a && lits[1] == b) return true;
+    if (lits[0] == b && lits[1] == a) return true;
+  }
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether a ternary clause consisting of the permutation of the given
+// literals  already exists or is subsumed by an existing binary clause.
+
+bool
+Internal::ternary_find_ternary_clause (int a, int b, int c) {
+  assert (occurring ());
+  assert (active (a));
+  assert (active (b));
+  assert (active (c));
+  size_t r = occs (a).size ();
+  size_t s = occs (b).size ();
+  size_t t = occs (c).size ();
+  int lit;
+  if (r < s) lit = (t < r) ? c : a;
+  else       lit = (t < s) ? c : b;
+  if (opts.ternaryocclim < (int) occs (lit).size ()) return true;
+  for (const auto & d : occs (lit)) {
+    const int * lits = d->literals;
+    if (d->size == 2) {
+      if (lits[0] == a && lits[1] == b) return true;
+      if (lits[0] == b && lits[1] == a) return true;
+      if (lits[0] == a && lits[1] == c) return true;
+      if (lits[0] == c && lits[1] == a) return true;
+      if (lits[0] == b && lits[1] == c) return true;
+      if (lits[0] == c && lits[1] == b) return true;
+    } else {
+      assert (d->size == 3);
+      if (lits[0] == a && lits[1] == b && lits[2] == c) return true;
+      if (lits[0] == a && lits[1] == c && lits[2] == b) return true;
+      if (lits[0] == b && lits[1] == a && lits[2] == c) return true;
+      if (lits[0] == b && lits[1] == c && lits[2] == a) return true;
+      if (lits[0] == c && lits[1] == a && lits[2] == b) return true;
+      if (lits[0] == c && lits[1] == b && lits[2] == a) return true;
+    }
+  }
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to resolve the two ternary clauses on the given pivot (assumed to
+// occur positively in the first clause, negatively in the second).  If the
+// resolvent hast four literals, is tautological, already exists or in the
+// case of a ternary resolvent is subsumed by an existing binary clause than
+// 'false' is returned.  The global 'clause' contains the resolvent and
+// needs to be cleared in any case.
+
+bool
+Internal::hyper_ternary_resolve (Clause * c, int pivot, Clause * d) {
+  LOG ("hyper binary resolving on pivot %d", pivot);
+  LOG (c, "1st antecedent");
+  LOG (d, "2nd antecedent");
+  stats.ternres++;
+  assert (c->size == 3);
+  assert (d->size == 3);
+  assert (clause.empty ());
+  for (const auto & lit : *c)
+    if (lit != pivot)
+      clause.push_back (lit);
+  for (const auto & lit : *d) {
+    if (lit == -pivot) continue;
+    if (lit == clause[0]) continue;
+    if (lit == -clause[0]) return false;
+    if (lit == clause[1]) continue;
+    if (lit == -clause[1]) return false;
+    clause.push_back (lit);
+  }
+  size_t size = clause.size ();
+  if (size > 3) return false;
+  if (size == 2 &&
+      ternary_find_binary_clause (clause[0], clause[1]))
+    return  false;
+  if (size == 3 &&
+      ternary_find_ternary_clause (clause[0], clause[1], clause[2]))
+    return  false;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Produce all ternary resolvents on literal 'pivot' and increment the
+// 'steps' counter by the number of clauses containing 'pivot' which are
+// used during this process.  The reason for choosing this metric to measure
+// the effort spent in 'ternary' is that it should be similar to one
+// propagation step during search.
+
+void Internal::ternary_lit (int pivot, int64_t & steps, int64_t & htrs) {
+  LOG ("starting hyper ternary resolutions on pivot %d", pivot);
+  for (const auto & c : occs (pivot)) {
+    if (htrs < 0) break;
+    if (c->garbage) continue;
+    if (c->size != 3) { assert (c->size == 2); continue; }
+    if (--steps < 0) break;
+    bool assigned = false;
+    for (const auto & lit : *c)
+      if (val (lit)) { assigned = true; break; }
+    if (assigned) continue;
+    for (const auto & d : occs (-pivot)) {
+      if (htrs < 0) break;
+      if (d->garbage) continue;
+      if (d->size != 3) { assert (d->size == 2); continue; }
+      for (const auto & lit : *d)
+        if (val (lit)) { assigned = true; break; }
+      if (assigned) continue;
+      assert (clause.empty ());
+      htrs--;
+      if (hyper_ternary_resolve (c, pivot, d)) {
+        size_t size = clause.size ();
+        bool red = (size == 3 || (c->redundant && d->redundant));
+        Clause * r = new_hyper_ternary_resolved_clause (red);
+        if (red) r->hyper = true;
+        clause.clear ();
+        LOG (r, "hyper ternary resolved");
+        stats.htrs++;
+        for (const auto & lit : *r)
+          occs (lit).push_back (r);
+        if (size == 2) {
+          LOG ("hyper ternary resolvent subsumes both antecedents");
+          mark_garbage (c);
+          mark_garbage (d);
+          stats.htrs2++;
+          break;
+        } else {
+          assert (r->size == 3);
+          stats.htrs3++;
+        }
+      } else {
+        LOG (clause, "ignoring size %zd resolvent", clause.size ());
+        clause.clear ();
+      }
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Same as 'ternary_lit' but pick the phase of the variable based on the
+// number of positive and negative occurrence.
+
+void Internal::ternary_idx (int idx, int64_t & steps, int64_t & htrs) {
+  assert (0 < idx);
+  assert (idx <= max_var);
+  if (!active (idx)) return;
+  if (!flags (idx).ternary) return;
+  int pos = occs (idx).size ();
+  int neg = occs (-idx).size ();
+  if (pos <= opts.ternaryocclim && neg <= opts.ternaryocclim) {
+    LOG ("index %d has %zd positive and %zd negative occurrences",
+       idx, occs (idx).size (), occs (-idx).size ());
+    int pivot = (neg < pos ? -idx : idx);
+    ternary_lit (pivot, steps, htrs);
+  }
+  flags (idx).ternary = false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// One round of ternary resolution over all variables.  As in 'block' and
+// 'elim' we maintain a persistent global flag 'ternary' for each variable,
+// which records, whether a ternary clause containing it was added.  Then we
+// can focus on those variables for which we have not tried ternary
+// resolution before and nothing changed for them since then.  This works
+// across multiple calls to 'ternary' as well as 'ternary_round' since this
+// 'ternary' variable flag is updated during adding (ternary) resolvents.
+// This function goes over each variable just once.
+
+bool Internal::ternary_round (int64_t & steps_limit, int64_t & htrs_limit) {
+
+  assert (!unsat);
+
+  int64_t bincon = 0, terncon = 0;
+
+  init_occs ();
+
+  for (const auto & c : clauses) {
+    if (c->garbage) continue;
+    if (c->size > 3) continue;
+    bool assigned = false, marked = false;
+    for (const auto & lit : *c) {
+      if (val (lit)) { assigned = true; break; }
+      if (flags (lit).ternary) marked = true;
+    }
+    if (assigned) continue;
+    if (c->size == 2) bincon++;
+    else {
+      assert (c->size == 3);
+      if (!marked) continue;
+      terncon++;
+    }
+
+    for (const auto & lit : *c)
+      occs (lit).push_back (c);
+  }
+
+  PHASE ("ternary", stats.ternary,
+    "connected %" PRId64 " ternary %.0f%% "
+    "and %" PRId64 " binary clauses %.0f%%",
+    terncon, percent (terncon, clauses.size ()),
+    bincon, percent (bincon, clauses.size ()));
+
+  // Try ternary resolution on all variables once.
+  //
+  for (auto idx : vars) {
+    if (terminated_asynchronously ()) break;
+    if (steps_limit < 0) break;
+    if (htrs_limit < 0) break;
+    ternary_idx (idx, steps_limit, htrs_limit);
+  }
+
+  // Gather some statistics for the verbose messages below and also
+  // determine whether new variables have been marked and it would make
+  // sense to run another round of ternary resolution over those variables.
+  //
+  int remain = 0;
+  for (auto idx : vars) {
+    if (!active (idx)) continue;
+    if (!flags (idx).ternary) continue;
+    remain++;
+  }
+  if (remain)
+    PHASE ("ternary", stats.ternary,
+      "%d variables remain %.0f%%",
+      remain, percent (remain, max_var));
+  else
+    PHASE ("ternary", stats.ternary,
+      "completed hyper ternary resolution");
+
+  reset_occs ();
+  assert (!unsat);
+
+  return remain;        // Are there variables that should be tried again?
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::ternary () {
+
+  if (!opts.ternary) return false;
+  if (unsat) return false;
+  if (terminated_asynchronously ()) return false;
+
+  // No new ternary clauses added since last time?
+  //
+  if (last.ternary.marked == stats.mark.ternary) return false;
+
+  START_SIMPLIFIER (ternary, TERNARY);
+  stats.ternary++;
+
+  assert (!level);
+
+  assert (!unsat);
+  if (watching ()) reset_watches ();
+
+  // The number of steps (see comment to 'ternary_lit' above) is global to
+  // all rounds of producing ternary resolvents on all marked variables in
+  // this call to the 'ternary' procedure.
+  //
+  int64_t steps_limit = stats.propagations.search;
+  steps_limit *= 1e-3 * opts.ternaryreleff;
+  if (steps_limit < opts.ternarymineff) steps_limit = opts.ternarymineff;
+  if (steps_limit > opts.ternarymaxeff) steps_limit = opts.ternarymaxeff;
+
+  // The number of clauses derived through ternary resolution can grow
+  // substantially, particularly for random formulas.  Thus we limit the
+  // number of added clauses too (actually the number of 'htrs').
+  //
+  int64_t htrs_limit = stats.current.redundant + stats.current.irredundant;
+  htrs_limit *= opts.ternarymaxadd;
+  htrs_limit /= 100;
+
+  // With 'stats.ternary' we actually count the number of calls to
+  // 'ternary_round' and not the number of calls to 'ternary'. But before
+  // the first round we want to show the limit on the number of steps and
+  // thus we increase counter for the first round here and skip increasing
+  // it in the loop below.
+  //
+  PHASE ("ternary", stats.ternary,
+    "will run a maximum of %d rounds "
+    "limited to %" PRId64 " steps and %" PRId64 " clauses",
+    opts.ternaryrounds, steps_limit, htrs_limit);
+
+  bool resolved_binary_clause = false;
+  bool completed = false;
+
+  for (int round = 0;
+       !terminated_asynchronously () && round < opts.ternaryrounds;
+       round++)
+  {
+    if (htrs_limit < 0) break;
+    if (steps_limit < 0) break;
+    if (round) stats.ternary++;
+    int old_htrs2 = stats.htrs2;
+    int old_htrs3 = stats.htrs3;
+    completed = ternary_round (steps_limit, htrs_limit);
+    int delta_htrs2 = stats.htrs2 - old_htrs2;
+    int delta_htrs3 = stats.htrs3 - old_htrs3;
+    PHASE ("ternary", stats.ternary,
+      "derived %d ternary and %d binary resolvents",
+      delta_htrs3, delta_htrs2);
+    report ('3', !opts.reportall && !(delta_htrs2 + delta_htrs2));
+    if (delta_htrs2) resolved_binary_clause = true;
+    if (!delta_htrs3) break;
+  }
+
+  assert (!occurring ());
+  assert (!unsat);
+  init_watches ();
+  connect_watches ();
+  if (!propagate ()) {
+    LOG ("propagation after connecting watches results in inconsistency");
+    learn_empty_clause ();
+  }
+
+  if (completed) last.ternary.marked = stats.mark.ternary;
+
+  STOP_SIMPLIFIER (ternary, TERNARY);
+
+  return resolved_binary_clause;
+}
+
+}
diff --git a/hCaD_V2/src/tracer.cpp b/hCaD_V2/src/tracer.cpp
new file mode 100644
index 0000000..2db8cde
--- /dev/null
+++ b/hCaD_V2/src/tracer.cpp
@@ -0,0 +1,86 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+Tracer::Tracer (Internal * i, File * f, bool b) :
+  internal (i),
+  file (f), binary (b),
+  added (0), deleted (0)
+{
+  (void) internal;
+  LOG ("TRACER new");
+}
+
+Tracer::~Tracer () {
+  LOG ("TRACER delete");
+  delete file;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Support for binary DRAT format.
+
+inline void Tracer::put_binary_zero () {
+  assert (binary);
+  assert (file);
+  file->put ((unsigned char) 0);
+}
+
+inline void Tracer::put_binary_lit (int lit) {
+  assert (binary);
+  assert (file);
+  assert (lit != INT_MIN);
+  unsigned x = 2*abs (lit) + (lit < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Tracer::add_derived_clause (const vector<int> & clause) {
+  if (file->closed ()) return;
+  LOG ("TRACER tracing addition of derived clause");
+  if (binary) file->put ('a');
+  for (const auto & external_lit : clause)
+    if (binary) put_binary_lit (external_lit);
+    else file->put (external_lit), file->put (' ');
+  if (binary) put_binary_zero ();
+  else file->put ("0\n");
+  added++;
+}
+
+void Tracer::delete_clause (const vector<int> & clause) {
+  if (file->closed ()) return;
+  LOG ("TRACER tracing deletion of clause");
+  if (binary) file->put ('d');
+  else file->put ("d ");
+  for (const auto & external_lit : clause)
+    if (binary) put_binary_lit (external_lit);
+    else file->put (external_lit), file->put (' ');
+  if (binary) put_binary_zero ();
+  else file->put ("0\n");
+  deleted++;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Tracer::closed () { return file->closed (); }
+
+void Tracer::close () { assert (!closed ()); file->close (); }
+
+void Tracer::flush () {
+  assert (!closed ());
+  file->flush ();
+  MSG ("traced %" PRId64 " added and %" PRId64 " deleted clauses",
+    added, deleted);
+}
+
+}
diff --git a/hCaD_V2/src/tracer.hpp b/hCaD_V2/src/tracer.hpp
new file mode 100644
index 0000000..cc8f303
--- /dev/null
+++ b/hCaD_V2/src/tracer.hpp
@@ -0,0 +1,36 @@
+#ifndef _tracer_h_INCLUDED
+#define _tracer_h_INCLUDED
+
+#include "observer.hpp" // Alphabetically after 'tracer'.
+
+// Proof tracing to a file (actually 'File') in DRAT format.
+
+namespace CaDiCaL {
+
+class Tracer : public Observer {
+
+  Internal * internal;
+  File * file;
+  bool binary;
+
+  int64_t added, deleted;
+
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+
+public:
+
+  Tracer (Internal *, File * file, bool binary); // own and delete 'file'
+  ~Tracer ();
+
+  void add_derived_clause (const vector<int> &);
+  void delete_clause (const vector<int> &);
+
+  bool closed ();
+  void close ();
+  void flush ();
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/transred.cpp b/hCaD_V2/src/transred.cpp
new file mode 100644
index 0000000..14e7081
--- /dev/null
+++ b/hCaD_V2/src/transred.cpp
@@ -0,0 +1,196 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Implement transitive reduction in the binary implication graph.  This is
+// important for hyper binary resolution, which has the risk to produce too
+// many hyper binary resolvents otherwise.  This algorithm only works on
+// binary clauses and is usually pretty fast.  It will also find some failed
+// literals (in the binary implication graph).
+
+void Internal::transred () {
+
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
+  if (!stats.current.redundant && !stats.current.irredundant) return;
+
+  assert (opts.transred);
+  assert (!level);
+
+  START_SIMPLIFIER (transred, TRANSRED);
+  stats.transreds++;
+
+  // Transitive reduction can not be run to completion for larger formulas
+  // with many binary clauses.  We bound it in the same way as 'probe_core'.
+  //
+  int64_t limit = stats.propagations.search;
+  limit -= last.transred.propagations;
+  limit *= 1e-3 * opts.transredreleff;
+  if (limit < opts.transredmineff) limit = opts.transredmineff;
+  if (limit > opts.transredmaxeff) limit = opts.transredmaxeff;
+
+  PHASE ("transred", stats.transreds,
+    "transitive reduction limit of %" PRId64 " propagations", limit);
+
+  const auto end = clauses.end ();
+  auto i = clauses.begin ();
+
+  // Find first clause not checked for being transitive yet.
+  //
+  for (; i != end; i++) {
+    Clause * c = *i;
+    if (c->garbage) continue;
+    if (c->size != 2) continue;
+    if (c->redundant && c->hyper) continue;
+    if (!c->transred) break;
+  }
+
+  // If all candidate clauses have been checked reschedule all.
+  //
+  if (i == end) {
+
+    PHASE ("transred", stats.transreds,
+      "rescheduling all clauses since no clauses to check left");
+    for (i = clauses.begin (); i != end; i++) {
+      Clause * c = *i;
+      if (c->transred) c->transred = false;
+    }
+    i = clauses.begin ();
+  }
+
+  // Move watches of binary clauses to the front. Thus we can stop iterating
+  // watches as soon a long clause is found during watch traversal.
+  //
+  sort_watches ();
+
+  // This working stack plays the same role as the 'trail' during standard
+  // propagation.
+  //
+  vector<int> work;
+
+  int64_t propagations = 0, units = 0, removed = 0;
+
+  while (!unsat &&
+         i != end &&
+         !terminated_asynchronously () &&
+         propagations < limit)
+  {
+    Clause * c = *i++;
+
+    // A clause is a candidate for being transitive if it is binary, and not
+    // the result of hyper binary resolution.  The reason for excluding
+    // those, is that they come in large numbers, most of them are reduced
+    // away anyhow and further are non-transitive at the point they are
+    // added (see the code in 'hyper_binary_resolve' in 'prope.cpp' and
+    // also check out our CPAIOR paper on tree-based look ahead).
+    //
+    if (c->garbage) continue;
+    if (c->size != 2) continue;
+    if (c->redundant && c->hyper) continue;
+    if (c->transred) continue;                  // checked before?
+    c->transred = true;                         // marked as checked
+
+    LOG (c, "checking transitive reduction of");
+
+    // Find a different path from 'src' to 'dst' in the binary implication
+    // graph, not using 'c'.  Since this is the same as checking whether
+    // there is a path from '-dst' to '-src', we can do the reverse search
+    // if the number of watches of '-dst' is larger than those of 'src'.
+    //
+    int src = -c->literals[0];
+    int dst = c->literals[1];
+    if (val (src) || val (dst)) continue;
+    if (watches (-src).size () < watches (dst).size ()) {
+      int tmp = dst;
+      dst = -src; src = -tmp;
+    }
+
+    LOG ("searching path from %d to %d", src, dst);
+
+    // If the candidate clause is irredundant then we can not use redundant
+    // binary clauses in the implication graph.  See our inprocessing rules
+    // paper, why this restriction is required.
+    //
+    const bool irredundant = !c->redundant;
+
+    assert (work.empty ());
+    mark (src);
+    work.push_back (src);
+    LOG ("transred assign %d", src);
+
+    bool transitive = false;            // found path from 'src' to 'dst'?
+    bool failed = false;                // 'src' failed literal?
+
+    size_t j = 0;                       // 'propagated' in BFS
+
+    while (!transitive && !failed && j < work.size ()) {
+      const int lit = work[j++];
+      assert (marked (lit) > 0);
+      LOG ("transred propagating %d", lit);
+      propagations++;
+      const Watches & ws = watches (-lit);
+      const const_watch_iterator eow = ws.end ();
+      const_watch_iterator k;
+      for (k = ws.begin (); !transitive && !failed && k != eow; k++) {
+        const Watch & w = *k;
+        if (!w.binary ()) break;        // since we sorted watches above
+        Clause * d = w.clause;
+        if (d == c) continue;
+        if (irredundant && d->redundant) continue;
+        if (d->garbage) continue;
+        const int other = w.blit;
+        if (other == dst) transitive = true;    // 'dst' reached
+        else {
+          const int tmp = marked (other);
+          if (tmp > 0) continue;
+          else if (tmp < 0) {
+            LOG ("found both %d and %d reachable", -other, other);
+            failed = true;
+          } else {
+            mark (other);
+            work.push_back (other);
+            LOG ("transred assign %d", other);
+          }
+        }
+      }
+    }
+
+    // Unassign all assigned literals (same as '[bp]acktrack').
+    //
+    while (!work.empty ()) {
+      const int lit = work.back ();
+      work.pop_back ();
+      unmark (lit);
+    }
+
+    if (transitive) {
+      removed++;
+      stats.transitive++;
+      LOG (c, "transitive redundant");
+      mark_garbage (c);
+    } else if (failed) {
+      units++;
+      LOG ("found failed literal %d during transitive reduction", src);
+      stats.failed++;
+      stats.transredunits++;
+      assign_unit (-src);
+      if (!propagate ()) {
+        VERBOSE (1, "propagating new unit results in conflict");
+        learn_empty_clause ();
+      }
+    }
+  }
+
+  last.transred.propagations = stats.propagations.search;
+  stats.propagations.transred += propagations;
+  erase_vector (work);
+
+  PHASE ("transred", stats.transreds,
+    "removed %" PRId64 " transitive clauses, found %" PRId64 " units",
+    removed, units);
+
+  STOP_SIMPLIFIER (transred, TRANSRED);
+  report ('t', !opts.reportall && !(removed + units));
+}
+
+}
diff --git a/hCaD_V2/src/util.cpp b/hCaD_V2/src/util.cpp
new file mode 100644
index 0000000..d012fcd
--- /dev/null
+++ b/hCaD_V2/src/util.cpp
@@ -0,0 +1,132 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+bool parse_int_str(const char * val_str, int & val)
+{
+  if (!strcmp (val_str, "true")) val = 1;
+  else if (!strcmp (val_str, "false")) val = 0;
+  else {
+    const char * p = val_str;
+    int sign;
+
+    if (*p == '-') sign = -1, p++;
+    else sign = 1;
+
+    int ch;
+    if (!isdigit ((ch = *p++))) return false;
+
+    const int64_t bound = - (int64_t) INT_MIN;
+    int64_t mantissa = ch - '0';
+
+    while (isdigit (ch = *p++)) {
+      if (bound / 10 < mantissa) mantissa = bound;
+      else mantissa *= 10;
+      const int digit = ch - '0';
+      if (bound - digit < mantissa) mantissa = bound;
+      else mantissa += digit;
+    }
+
+    int exponent = 0;
+    if (ch  == 'e') {
+      while (isdigit ((ch = *p++)))
+        exponent = exponent ? 10 : ch - '0';
+      if (ch) return false;
+    } else if (ch) return false;
+
+    assert (exponent <= 10);
+    int64_t val64 = mantissa;
+    for (int i = 0; i < exponent; i++) val64 *= 10;
+
+    if (sign < 0) {
+      val64 = -val64;
+      if (val64 < INT_MIN) val64 = INT_MIN;
+    } else {
+      if (val64 > INT_MAX) val64 = INT_MAX;
+    }
+
+    assert (INT_MIN <= val64);
+    assert (val64 <= INT_MAX);
+
+    val = val64;
+  }
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool has_suffix (const char * str, const char * suffix) {
+  size_t k = strlen (str), l = strlen (suffix);
+  return k > l && !strcmp (str + k - l, suffix);
+}
+
+bool has_prefix (const char * str, const char * prefix) {
+  for (const char * p = str, * q = prefix; *q; q++, p++)
+    if (*q != *p)
+      return false;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool is_color_option (const char * arg) {
+  return !strcmp (arg, "--color") ||
+         !strcmp (arg, "--colors") ||
+         !strcmp (arg, "--colour") ||
+         !strcmp (arg, "--colours") ||
+         !strcmp (arg, "--color=1") ||
+         !strcmp (arg, "--colors=1") ||
+         !strcmp (arg, "--colour=1") ||
+         !strcmp (arg, "--colours=1") ||
+         !strcmp (arg, "--color=true") ||
+         !strcmp (arg, "--colors=true") ||
+         !strcmp (arg, "--colour=true") ||
+         !strcmp (arg, "--colours=true");
+}
+
+bool is_no_color_option (const char * arg) {
+  return !strcmp (arg, "--no-color") ||
+         !strcmp (arg, "--no-colors") ||
+         !strcmp (arg, "--no-colour") ||
+         !strcmp (arg, "--no-colours") ||
+         !strcmp (arg, "--color=0") ||
+         !strcmp (arg, "--colors=0") ||
+         !strcmp (arg, "--colour=0") ||
+         !strcmp (arg, "--colours=0") ||
+         !strcmp (arg, "--color=false") ||
+         !strcmp (arg, "--colors=false") ||
+         !strcmp (arg, "--colour=false") ||
+         !strcmp (arg, "--colours=false");
+}
+
+/*------------------------------------------------------------------------*/
+
+static uint64_t primes[] = {
+  1111111111111111111lu,
+  2222222222222222249lu,
+  3333333333333333347lu,
+  4444444444444444537lu,
+  5555555555555555621lu,
+  6666666666666666677lu,
+  7777777777777777793lu,
+  8888888888888888923lu,
+  9999999999999999961lu,
+};
+
+uint64_t hash_string (const char * str) {
+  const unsigned size = sizeof primes / sizeof *primes;
+  uint64_t res = 0;
+  unsigned char ch;
+  unsigned i = 0;
+  for (const char * p = str; (ch = *p); p++) {
+    res += ch;
+    res *= primes[i++];
+    if (i == size)
+      i = 0;
+  }
+  return res;
+}
+
+}
diff --git a/hCaD_V2/src/util.hpp b/hCaD_V2/src/util.hpp
new file mode 100644
index 0000000..7a94f23
--- /dev/null
+++ b/hCaD_V2/src/util.hpp
@@ -0,0 +1,121 @@
+#ifndef _util_hpp_INCLUDED
+#define _util_hpp_INCLUDED
+
+#include <vector>
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// Common simple utility functions independent from 'Internal'.
+
+/*------------------------------------------------------------------------*/
+
+inline double relative (double a, double b) { return b ? a / b : 0; }
+inline double percent (double a, double b) { return relative (100 * a, b); }
+inline int sign (int lit) { return (lit > 0) - (lit < 0); }
+inline unsigned bign (int lit) { return 1 + (lit < 0); }
+
+/*------------------------------------------------------------------------*/
+
+bool has_suffix (const char * str, const char * suffix);
+bool has_prefix (const char * str, const char * prefix);
+
+/*------------------------------------------------------------------------*/
+
+// Parse integer string in the form of
+//
+//   true
+//   false
+//   [-]<mantissa>[e<exponent>]
+//
+// and in the latter case '<val>' has to be within [-INT_MAX,INT_MAX].
+//
+// The function returns true if parsing is successful and then also sets
+// the second argument to the parsed value.
+
+bool parse_int_str (const char * str, int &);
+
+/*------------------------------------------------------------------------*/
+
+inline bool is_power_of_two (unsigned n) { return n && !(n & (n-1)); }
+
+inline bool
+contained (int64_t c, int64_t l, int64_t u) { return l <= c && c <= u; }
+
+inline bool aligned (size_t n, size_t alignment) {
+  assert (is_power_of_two (alignment));
+  const size_t mask = alignment - 1;
+  return !(n & mask);
+}
+
+inline size_t align (size_t n, size_t alignment) {
+  size_t res = n;
+  assert (is_power_of_two (alignment));
+  const size_t mask = alignment - 1;
+  if (res & mask) res = (res | mask) + 1;
+  assert (aligned (res, alignment));
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline bool parity (unsigned a) {
+  assert (sizeof a == 4);
+  unsigned tmp = a;
+  tmp ^= (tmp >> 16);
+  tmp ^= (tmp >> 8);
+  tmp ^= (tmp >> 4);
+  tmp ^= (tmp >> 2);
+  tmp ^= (tmp >> 1);
+  return tmp & 1;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The standard 'Effective STL' way (though not guaranteed) to clear a
+// vector and reduce its capacity to zero, thus deallocating all its
+// internal memory.  This is quite important for keeping the actual
+// allocated size of watched and occurrence lists small particularly during
+// bounded variable elimination where many clauses are added and removed.
+
+template<class T> void erase_vector (vector<T> & v) {
+  if (v.capacity ()) { std::vector<T>().swap (v); }
+  assert (!v.capacity ());                          // not guaranteed though
+}
+
+// The standard 'Effective STL' way (though not guaranteed) to shrink the
+// capacity of a vector to its size thus kind of releasing all the internal
+// excess memory not needed at the moment any more.
+
+template<class T> void shrink_vector (vector<T> & v) {
+  if (v.capacity () > v.size ()) { vector<T>(v).swap (v); }
+  assert (v.capacity () == v.size ());              // not guaranteed though
+}
+
+/*------------------------------------------------------------------------*/
+
+template<class T>
+inline void clear_n (T * base, size_t n) {
+  memset (base, 0, sizeof (T) * n);
+}
+
+/*------------------------------------------------------------------------*/
+
+// These are options both to 'cadical' and 'mobical'.  After wasting some
+// on not remembering the spelling (British vs American), nor singular vs
+// plural and then wanted to use '--color=false', and '--colours=0' too, I
+// just factored this out into these two utility functions.
+
+bool is_color_option (const char * arg);    // --color, --colour, ...
+bool is_no_color_option (const char * arg); // --no-color, --no-colour, ...
+
+/*------------------------------------------------------------------------*/
+
+uint64_t hash_string (const char * str);
+
+/*------------------------------------------------------------------------*/
+
+}
+
+#endif
diff --git a/hCaD_V2/src/var.cpp b/hCaD_V2/src/var.cpp
new file mode 100644
index 0000000..cc27258
--- /dev/null
+++ b/hCaD_V2/src/var.cpp
@@ -0,0 +1,33 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::reset_subsume_bits () {
+  LOG ("marking all variables as not subsume");
+  for (auto idx : vars)
+    flags (idx).subsume = false;
+}
+
+void Internal::check_var_stats () {
+#ifndef NDEBUG
+  int64_t fixed = 0, eliminated = 0, substituted = 0, pure = 0, unused = 0;
+  for (auto idx : vars) {
+    Flags & f = flags (idx);
+    if (f.active ()) continue;
+    if (f.fixed ()) fixed++;
+    if (f.eliminated ()) eliminated++;
+    if (f.substituted ()) substituted++;
+    if (f.unused ()) unused++;
+    if (f.pure ()) pure++;
+  }
+  assert (stats.now.fixed == fixed);
+  assert (stats.now.eliminated == eliminated);
+  assert (stats.now.substituted == substituted);
+  assert (stats.now.pure == pure);
+  int64_t inactive = unused + fixed + eliminated + substituted + pure;
+  assert (stats.inactive == inactive);
+  assert (max_var == stats.active + stats.inactive);
+#endif
+}
+
+}
diff --git a/hCaD_V2/src/var.hpp b/hCaD_V2/src/var.hpp
new file mode 100644
index 0000000..2a666e5
--- /dev/null
+++ b/hCaD_V2/src/var.hpp
@@ -0,0 +1,22 @@
+#ifndef _var_hpp_INCLUDED
+#define _var_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Clause;
+
+// This structure captures data associated with an assigned variable.
+
+struct Var {
+
+  // Note that none of these members is valid unless the variable is
+  // assigned.  During unassigning a variable we do not reset it.
+
+  int level;         // decision level
+  int trail;         // trail height at assignment
+  Clause * reason;   // implication graph edge during search
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/version.cpp b/hCaD_V2/src/version.cpp
new file mode 100644
index 0000000..1b81af0
--- /dev/null
+++ b/hCaD_V2/src/version.cpp
@@ -0,0 +1,97 @@
+/*------------------------------------------------------------------------*/
+
+// To simplify the build process without 'make', you can disable the
+// generation of 'build.hpp' through '../scripts/make-build-header.sh' by
+// defining '-DNBUILD'.  Then we try to guess part of the configuration.
+
+#ifndef NBUILD
+#if __GNUC__ > 4
+#if __has_include(<build.hpp>)
+#include <build.hpp>
+#endif // __has_include
+#else
+#include <build.hpp>
+#endif // __GNUC > 4
+#endif // NBUILD
+
+/*------------------------------------------------------------------------*/
+
+// We prefer short 3 character version numbers made of digits and lower case
+// letters only, which gives 36^3 = 46656 different versions.  The following
+// macro is used for the non-standard build process and only set from
+// the file '../VERSION' with '../scripts/update-version.sh'.  The standard
+// build process relies on 'VERSION' to be defined in 'build.hpp'.
+
+#ifdef NBUILD
+#ifndef VERSION
+#  define VERSION "sc2021"
+#endif // VERSION
+#endif // NBUILD
+
+/*------------------------------------------------------------------------*/
+
+// The copyright of the code is here.
+
+static const char * COPYRIGHT =
+"Copyright (c) 2016-2021 Armin Biere, Mathias Fleury, JKU Linz"
+;
+
+/*------------------------------------------------------------------------*/
+
+// Again if we do not have 'NBUILD' or if something during configuration is
+// broken we still want to be able to compile the solver.  In this case we
+// then try our best to figure out 'COMPILER' and 'DATE', but for
+// 'IDENTIFIER' and 'FLAGS' we can only use the '0' string, which marks
+// those as unknown.
+
+#ifndef COMPILER
+#  ifdef __clang__
+#    ifdef __VERSION__
+#      define COMPILER "clang++-" __VERSION__
+#    else
+#      define COMPILER "clang++"
+#    endif
+#  elif defined (__GNUC__)
+#    ifdef __VERSION__
+#      define COMPILER "g++-" __VERSION__
+#    else
+#      define COMPILER "g++"
+#    endif
+#  else
+#    define COMPILER 0
+#  endif
+#endif
+
+// GIT SHA2 identifier.
+//
+#ifndef IDENTIFIER
+#  define IDENTIFIER 0
+#endif
+
+// Compilation flags.
+//
+#ifndef FLAGS
+#  define FLAGS 0
+#endif
+
+// Build Time and operating system.
+//
+#ifndef DATE
+#  define DATE __DATE__ " " __TIME__
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#include "version.hpp"
+
+namespace CaDiCaL {
+
+const char * version () { return VERSION; }
+const char * copyright () { return COPYRIGHT; }
+const char * signature () { return "cadical-" VERSION; }
+const char * identifier () { return IDENTIFIER; }
+const char * compiler () { return COMPILER; }
+const char * date () { return DATE; }
+const char * flags () { return FLAGS; }
+
+}
diff --git a/hCaD_V2/src/version.hpp b/hCaD_V2/src/version.hpp
new file mode 100644
index 0000000..ce48573
--- /dev/null
+++ b/hCaD_V2/src/version.hpp
@@ -0,0 +1,11 @@
+namespace CaDiCaL {
+
+const char * version ();
+const char * copyright ();
+const char * signature ();
+const char * identifier ();
+const char * compiler ();
+const char * date ();
+const char * flags ();
+
+}
diff --git a/hCaD_V2/src/vivify.cpp b/hCaD_V2/src/vivify.cpp
new file mode 100644
index 0000000..324f43a
--- /dev/null
+++ b/hCaD_V2/src/vivify.cpp
@@ -0,0 +1,1097 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Vivification is a special case of asymmetric tautology elimination (ATE)
+// and asymmetric literal elimination (ALE).  It strengthens and removes
+// clauses proven redundant through unit propagation.
+//
+// The original algorithm is due to a paper by Piette, Hamadi and Sais
+// published at ECAI'08.  We have an inprocessing version, e.g., it does not
+// necessarily run-to-completion.  Our version also performs conflict
+// analysis and uses a new heuristic for selecting clauses to vivify.
+
+// Our idea is to focus on clauses with many occurrences of its literals in
+// other clauses first.  This both complements nicely our implementation of
+// subsume, which is bounded, e.g., subsumption attempts are skipped for
+// very long clauses with literals with many occurrences and also is
+// stronger in the sense that it enables to remove more clauses due to unit
+// propagation (AT checks).
+
+// While first focusing on irredundant clause we then added a separate phase
+// upfront which focuses on strengthening also redundant clauses in spirit
+// of the ideas presented in the IJCAI'17 paper by M. Luo, C.-M. Li, F.
+// Xiao, F. Manya, and Z. Lu.
+
+// There is another very similar approach called 'distilliation' published
+// by Han and Somenzi in DAC'07, which reorganizes the CNF in a trie data
+// structure to reuse decisions and propagations along the trie.  We used
+// that as an inspiration but instead of building a trie we simple sort
+// clauses and literals in such a way that we get the same effect.  If a new
+// clause is 'distilled' or 'vivified' we first check how many of the
+// decisions (which are only lazily undone) can be reused for that clause.
+// Reusing can be improved by picking a global literal order and sorting the
+// literals in all clauses with respect to that order.  We favor literals
+// with more occurrences first.  Then we sort clauses lexicographically with
+// respect to that literal order.
+
+/*------------------------------------------------------------------------*/
+
+// For vivification we have a separate dedicated propagation routine, which
+// prefers to propagate binary clauses first.  It also uses its own
+// assignment procedure 'vivify_assign', which does not mess with phase
+// saving during search nor the conflict and other statistics and further
+// can be inlined separately here.  The propagation routine needs to ignore
+// (large) clauses which are currently vivified.
+
+inline void Internal::vivify_assign (int lit, Clause * reason) {
+  require_mode (VIVIFY);
+  const int idx = vidx (lit);
+  assert (!vals[idx]);
+  assert (!flags (idx).eliminated () || !reason);
+  Var & v = var (idx);
+  v.level = level;                      // required to reuse decisions
+  v.trail = (int) trail.size ();        // used in 'vivify_better_watch'
+  v.reason = level ? reason : 0;        // for conflict analysis
+  if (!level) learn_unit_clause (lit);
+  const signed char tmp = sign (lit);
+  vals[idx] = tmp;
+  vals[-idx] = -tmp;
+  assert (val (lit) > 0);
+  assert (val (-lit) < 0);
+  trail.push_back (lit);
+  LOG (reason, "vivify assign %d", lit);
+}
+
+// Assume negated literals in candidate clause.
+
+void Internal::vivify_assume (int lit) {
+  require_mode (VIVIFY);
+  level++;
+  control.push_back (Level (lit, trail.size ()));
+  LOG ("vivify decide %d", lit);
+  assert (level > 0);
+  assert (propagated == trail.size ());
+  vivify_assign (lit, 0);
+}
+
+// Dedicated routine similar to 'propagate' in 'propagate.cpp' and
+// 'probe_propagate' with 'probe_propagate2' in 'probe.cpp'.  Please refer
+// to that code for more explanation on how propagation is implemented.
+
+bool Internal::vivify_propagate () {
+  require_mode (VIVIFY);
+  assert (!unsat);
+  START (propagate);
+  int64_t before = propagated2 = propagated;
+  for (;;) {
+    if (propagated2 != trail.size ()) {
+      const int lit = -trail[propagated2++];
+      LOG ("vivify propagating %d over binary clauses", -lit);
+      Watches & ws = watches (lit);
+      for (const auto & w : ws) {
+        if (!w.binary ()) continue;
+        const signed char b = val (w.blit);
+        if (b > 0) continue;
+        if (b < 0) conflict = w.clause;                 // but continue
+        else vivify_assign (w.blit, w.clause);
+      }
+    } else if (!conflict && propagated != trail.size ()) {
+      const int lit = -trail[propagated++];
+      LOG ("vivify propagating %d over large clauses", -lit);
+      Watches & ws = watches (lit);
+      const const_watch_iterator eow = ws.end ();
+      const_watch_iterator i = ws.begin ();
+      watch_iterator j = ws.begin ();
+      while (i != eow) {
+        const Watch w = *j++ = *i++;
+        if (w.binary ()) continue;
+        if (val (w.blit) > 0) continue;
+        if (w.clause->garbage) { j--; continue; }
+        if (w.clause == ignore) continue;
+        literal_iterator lits = w.clause->begin ();
+        const int other = lits[0]^lits[1]^lit;
+        const signed char u = val (other);
+        if (u > 0) j[-1].blit = other;
+        else {
+          const int size = w.clause->size;
+          const const_literal_iterator end = lits + size;
+          const literal_iterator middle = lits + w.clause->pos;
+          literal_iterator k = middle;
+          signed char v = -1;
+          int r = 0;
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+          if (v < 0) {
+            k = lits + 2;
+            assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+          w.clause->pos = k - lits;
+          assert (lits + 2 <= k), assert (k <= w.clause->end ());
+          if (v > 0) j[-1].blit = r;
+          else if (!v) {
+            LOG (w.clause, "unwatch %d in", r);
+            lits[0] = other;
+            lits[1] = r;
+            *k = lit;
+            watch_literal (r, lit, w.clause);
+            j--;
+          } else if (!u) {
+            assert (v < 0);
+            vivify_assign (other, w.clause);
+          } else {
+            assert (u < 0);
+            assert (v < 0);
+            conflict = w.clause;
+            break;
+          }
+        }
+      }
+      if (j != i) {
+        while (i != eow)
+          *j++ = *i++;
+        ws.resize (j - ws.begin ());
+      }
+    } else break;
+  }
+  int64_t delta = propagated2 - before;
+  stats.propagations.vivify += delta;
+  if (conflict) LOG (conflict, "conflict");
+  STOP (propagate);
+  return !conflict;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether a literal occurs less often.  In the implementation below
+// (search for 'int64_t score = ...' or '@4') we actually compute a
+// weighted occurrence count similar to the Jeroslow Wang heuristic.
+
+struct vivify_more_noccs {
+
+  Internal * internal;
+
+  vivify_more_noccs (Internal * i) : internal (i) { }
+
+  bool operator () (int a, int b) {
+    int64_t n = internal->noccs (a);
+    int64_t m = internal->noccs (b);
+    if (n > m) return true;     // larger occurrences / score first
+    if (n < m) return false;    // smaller occurrences / score last
+    if (a == -b) return a > 0;  // positive literal first
+    return abs (a) < abs (b);   // smaller index first
+  }
+};
+
+// Sort candidate clauses by the number of occurrences (actually by their
+// score) of their literals, with clauses to be vivified first last.   We
+// assume that clauses are sorted w.r.t. more occurring (higher score)
+// literals first (with respect to 'vivify_more_noccs').
+//
+// For example if there are the following (long irredundant) clauses
+//
+//   1 -3 -4      (A)
+//  -1 -2  3 4    (B)
+//   2 -3  4      (C)
+//
+// then we have the following literal scores using Jeroslow Wang scores and
+// normalizing it with 2^12 (which is the same as 1<<12):
+//
+//  nocc ( 1) = 2^12 * (2^-3       ) =  512  3.
+//  nocc (-1) = 2^12 * (2^-4       ) =  256  6.
+//  nocc ( 2) = 2^12 * (2^-3       ) =  512  4.
+//  nocc (-2) = 2^12 * (2^-4       ) =  256  7.                 @1
+//  nocc ( 3) = 2^12 * (2^-4       ) =  256  8.
+//  nocc (-3) = 2^12 * (2^-3 + 2^-3) = 1024  1.
+//  nocc ( 4) = 2^12 * (2^-3 + 2^-4) =  768  2.
+//  nocc (-4) = 2^12 * (2^-3       ) =  512  5.
+//
+// which gives the literal order (according to 'vivify_more_noccs')
+//
+//  -3, 4, 1, 2, -4, -1, -2, 3
+//
+// Then sorting the literals in each clause gives
+//
+//  -3  1 -4     (A')
+//   4 -1 -2  3  (B')                                           @2
+//  -3  4  2     (C')
+//
+// and finally sorting those clauses lexicographically w.r.t. scores is
+//
+//  -3  4  2     (C')
+//  -3  1 -4     (A')                                           @3
+//   4 -1 -2  3  (B')
+//
+// This order is defined by 'vivify_clause_later' which returns 'true' if
+// the first clause should be vivified later than the second.
+
+struct vivify_clause_later {
+
+  Internal * internal;
+
+  vivify_clause_later (Internal * i) : internal (i) { }
+
+  bool operator () (Clause * a, Clause * b) const {
+
+    // First focus on clauses scheduled in the last vivify round but not
+    // checked yet since then.
+    //
+    if (!a->vivify && b->vivify) return true;
+    if (a->vivify && !b->vivify) return false;
+
+    // Among redundant clauses (in redundant mode) prefer small glue.
+    //
+    if (a->redundant) {
+      assert (b->redundant);
+      if (a->glue > b->glue) return true;
+      if (a->glue < b->glue) return false;
+    }
+
+    // Then prefer shorter size.
+    //
+    if (a->size > b->size) return true;
+    if (a->size < b->size) return false;
+
+    // Now compare literals in the clauses lexicographically with respect to
+    // the literal order 'vivify_more_noccs' assuming literals are sorted
+    // decreasingly with respect to that order.
+    //
+    const auto eoa = a->end (), eob = b->end ();
+    auto j = b->begin ();
+    for (auto i = a->begin (); i != eoa && j != eob; i++, j++)
+      if (*i != *j) return vivify_more_noccs (internal) (*j, *i);
+
+    return j == eob;    // Prefer shorter clauses to be vivified first.
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Attempting on-the-fly subsumption during sorting when the last line is
+// reached in 'vivify_clause_later' above turned out to be trouble some for
+// identical clauses.  This is the single point where 'vivify_clause_later'
+// is not asymmetric and would require 'stable' sorting for determinism.  It
+// can also not be made 'complete' on-the-fly.  Instead of on-the-fly
+// subsumption we thus go over the sorted scheduled in a linear scan
+// again and remove certain subsumed clauses (the subsuming clause is
+// syntactically a prefix of the subsumed clause), which includes
+// those troublesome syntactically identical clauses.
+
+struct vivify_flush_smaller {
+
+  bool operator () (Clause * a, Clause * b) const {
+
+    const auto eoa = a->end (), eob = b->end ();
+    auto i = a->begin (), j = b->begin ();
+    for (; i != eoa && j != eob; i++, j++)
+      if (*i != *j) return *i < *j;
+
+    return j == eob && i != eoa;
+  }
+};
+
+void Internal::flush_vivification_schedule (Vivifier & vivifier) {
+
+  auto & schedule = vivifier.schedule;
+
+  stable_sort (schedule.begin (), schedule.end (), vivify_flush_smaller ());
+
+  const auto end = schedule.end ();
+  auto j = schedule.begin (), i = j;
+
+  Clause * prev = 0;
+  int64_t subsumed = 0;
+  for (; i != end; i++) {
+    Clause * c = *j++ = *i;
+    if (!prev || c->size < prev->size) { prev = c; continue; }
+    const auto eop = prev->end ();
+    auto k = prev->begin ();
+    for (auto l = c->begin (); k != eop; k++, l++)
+      if (*k != *l) break;
+    if (k == eop) {
+      LOG (c, "found subsumed");
+      LOG (prev, "subsuming");
+      assert (!c->garbage);
+      assert (!prev->garbage);
+      assert (c->redundant || !prev->redundant);
+      mark_garbage (c);
+      subsumed++;
+      j--;
+    } else prev = c;
+  }
+
+  if (subsumed)
+    PHASE ("vivify", stats.vivifications,
+       "flushed %" PRId64 " subsumed scheduled clauses", subsumed);
+
+  stats.vivifysubs += subsumed;
+
+  if (subsumed) {
+    schedule.resize (j - schedule.begin ());
+    shrink_vector (schedule);
+  } else assert (j == end);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Depending on whether we try to vivify redundant or irredundant clauses,
+// we schedule a clause to be vivified.  For redundant clauses we only try
+// to vivify them if they are likely to survive the next 'reduce' operation.
+
+bool Internal::consider_to_vivify_clause (Clause * c,
+                                          bool redundant_mode) {
+  if (c->garbage) return false;
+  if (c->redundant != redundant_mode) return false;
+  if (opts.vivifyonce >= 1 && c->redundant && c->vivified) return false;
+  if (opts.vivifyonce >= 2 && !c->redundant && c->vivified) return false;
+  if (c->redundant && !likely_to_be_kept_clause (c)) return false;
+  return true;
+}
+
+// Conflict analysis from 'start' which learns a decision only clause.
+
+void Internal::vivify_analyze_redundant (Vivifier & vivifier,
+                                         Clause * start,
+                                         bool & only_binary_reasons)
+{
+  LOG ("analyzing conflict in redundant mode");
+
+  only_binary_reasons = true;
+
+  auto & stack = vivifier.stack;
+  stack.clear ();
+
+  stack.push_back (start);
+  while (!stack.empty ()) {
+    Clause * c = stack.back ();
+    if (c->size > 2) only_binary_reasons = false;
+    stack.pop_back ();
+    LOG (c, "vivify analyze");
+    for (const auto & lit : *c) {
+      Var & v = var (lit);
+      if (!v.level) continue;
+      Flags & f = flags (lit);
+      if (f.seen) continue;
+      assert (val (lit) < 0);
+      f.seen = true;
+      analyzed.push_back (lit);
+      if (v.reason) stack.push_back (v.reason);
+      else LOG ("vivify seen %d", lit);
+    }
+  }
+
+  if (only_binary_reasons) LOG ("all reasons are binary");
+}
+
+// Check whether we assigned all literals to false and none is implied.
+
+bool Internal::vivify_all_decisions (Clause * c, int subsume) {
+
+  // assert (redundant_mode);
+
+  for (const auto & other : *c) {
+    if (other == subsume) continue;
+    if (val (other) >= 0) return false;
+    Var & v = var (other);
+    if (!v.level) continue;
+    if (v.reason) return false;
+    if (!flags (other).seen) return false;
+  }
+
+  return true;
+}
+
+// After conflict analysis (in redundant mode) we check whether all literals
+// in the candidate clause 'c' are actually decisions.  If that is case we do
+// not subsume the clause 'c'.  Otherwise we go over it and add literals to
+// the global learned clause which should be kept.  Thus the result of this
+// function is communicated through the global 'clause'.  If it becomes empty,
+// we do not learn it and subsumption fails.   The 'subsume' literal is used
+// to force keeping that literal (see case '@5' below, where we found this
+// positively implied literal).
+
+void Internal::vivify_post_process_analysis (Clause * c, int subsume) {
+
+  // assert (redundant_mode);
+
+  if (vivify_all_decisions (c, subsume)) {
+
+    LOG ("analyzed literals are all decisions thus no strengthening");
+
+    clause.clear ();    // Do not subsume nor strengthen (case '@7').
+
+  } else {              // Otherwise prepare subsuming learned clause.
+
+    for (const auto & other : *c) {
+
+      enum { FLUSH, IGNORE, KEEP } action;
+
+           if (other == subsume)     action = KEEP;
+      else if (val (other) >= 0)     action = FLUSH;
+      else {
+        Var & v = var (other);
+             if (!v.level)           action = IGNORE;
+        else if (v.reason)           action = FLUSH;
+        else if (flags (other).seen) action = KEEP;
+        else                         action = FLUSH;
+      }
+
+      if (action == KEEP) clause.push_back (other);
+#ifdef LOGGING
+      if (action == KEEP)   LOG ("keeping literal %d", other);
+      if (action == FLUSH)  LOG ("flushing literal %d", other);
+      if (action == IGNORE) LOG ("ignoring literal %d", other);
+#endif
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// In a strengthened clause the idea is to move non-false literals to the
+// front, followed by false literals.  Literals are further sorted by
+// reverse assignment order.  The goal is to use watches which require to
+// backtrack as few as possible decision levels.
+
+struct vivify_better_watch {
+
+  Internal * internal;
+
+  vivify_better_watch (Internal * i) : internal (i) { }
+
+  bool operator () (int a, int b) {
+
+    const signed char av = internal->val (a), bv = internal->val (b);
+
+    if (av >= 0 && bv < 0) return true;
+    if (av < 0 && bv >= 0) return false;
+
+    return internal->var (a).trail > internal->var (b).trail;
+  }
+};
+
+// Common code to actually strengthen a candidate clause.  The resulting
+// strengthened clause is communicated through the global 'clause'.
+
+void Internal::vivify_strengthen (Clause * c) {
+
+  assert (!clause.empty ());
+  stats.vivifystrs++;
+
+  if (clause.size () == 1) {
+
+    backtrack ();
+    const int unit = clause[0];
+    LOG (c, "vivification shrunken to unit %d", unit);
+    assert (!val (unit));
+    assign_unit (unit);
+    stats.vivifyunits++;
+
+    bool ok = propagate ();
+    if (!ok) learn_empty_clause ();
+
+  } else {
+
+    // See explanation before 'vivify_better_watch' above.
+    //
+    sort (clause.begin (), clause.end (), vivify_better_watch (this));
+
+    int new_level = level;
+
+    const int lit0 = clause[0];
+    signed char val0 = val (lit0);
+    if (val0 < 0) {
+      const int level0 = var (lit0).level;
+      LOG ("1st watch %d negative at level %d", lit0, level0);
+      new_level = level0 - 1;
+    }
+
+    const int lit1 = clause[1];
+    const signed char val1 = val (lit1);
+    if (val1 < 0 &&
+        !(val0 > 0 && var (lit0).level <= var (lit1).level)) {
+      const int level1 = var (lit1).level;
+      LOG ("2nd watch %d negative at level %d", lit1, level1);
+      new_level = level1 - 1;
+    }
+
+    if (new_level < level) backtrack (new_level);
+
+    assert (val (lit0) >= 0);
+    assert (val (lit1) >= 0 ||
+            (val (lit0) > 0 &&
+             val (lit1) < 0 &&
+             var (lit0).level <= var (lit1).level));
+
+    Clause * d = new_clause_as (c);
+    LOG (c, "before vivification");
+    LOG (d, "after vivification");
+    (void) d;
+  }
+  clause.clear ();
+  mark_garbage (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Main function: try to vivify this candidate clause in the given mode.
+
+void Internal::vivify_clause (Vivifier & vivifier, Clause * c) {
+
+  const bool redundant_mode = vivifier.redundant_mode;
+
+  assert (redundant_mode || !c->redundant);
+  assert (c->size > 2);                       // see (NO-BINARY) below
+
+  c->vivify = false;                          // mark as checked / tried
+  c->vivified = true;                         // and globally remember
+
+  if (c->garbage) return;
+
+  // First check whether the candidate clause is already satisfied and at
+  // the same time copy its non fixed literals to 'sorted'.  The literals
+  // in the candidate clause might not be sorted anymore due to replacing
+  // watches during propagation, even though we sorted them initially
+  // while pushing the clause onto the schedule and sorting the schedule.
+  //
+  int satisfied = 0;
+  auto & sorted = vivifier.sorted;
+  sorted.clear ();
+
+  for (const auto & lit : *c) {
+    const int tmp = fixed (lit);
+    if (tmp > 0) { satisfied = lit; break; }
+    else if (!tmp) sorted.push_back (lit);
+  }
+
+  if (satisfied) {
+    LOG (c, "satisfied by propagated unit %d", satisfied);
+    mark_garbage (c);
+    return;
+  }
+
+  sort (sorted.begin (), sorted.end (), vivify_more_noccs (this));
+
+  // The actual vivification checking is performed here, by assuming the
+  // negation of each of the remaining literals of the clause in turn and
+  // propagating it.  If a conflict occurs or another literal in the
+  // clause becomes assigned during propagation, we can stop.
+  //
+  LOG (c, "vivification checking");
+  stats.vivifychecks++;
+
+  // If the decision 'level' is non-zero, then we can reuse decisions for
+  // the previous candidate, and avoid re-propagating them.  In preliminary
+  // experiments this saved between 30%-50% decisions (and thus
+  // propagations), which in turn lets us also vivify more clauses within
+  // the same propagation bounds, or terminate earlier if vivify runs to
+  // completion.
+  //
+  if (level) {
+#ifdef LOGGING
+    int orig_level = level;
+#endif
+    // First check whether this clause is actually a reason for forcing
+    // one of its literals to true and then backtrack one level before
+    // that happened.  Otherwise this clause might be incorrectly
+    // considered to be redundant or if this situation is checked then
+    // redundancy by other clauses using this forced literal becomes
+    // impossible.
+    //
+    int forced = 0;
+
+    // This search could be avoided if we would eagerly set the 'reason'
+    // boolean flag of clauses, which however we do not want to do for
+    // binary clauses (during propagation) and thus would still require
+    // a version of 'protect_reason' for binary clauses during 'reduce'
+    // (well binary clauses are not collected during 'reduce', but again
+    // this exception from the exception is pretty complex and thus a
+    // simply search here is probably easier to understand).
+
+    for (const auto & lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp < 0) continue;
+      if (tmp > 0 && var (lit).reason == c) forced = lit;
+      break;
+    }
+    if (forced) {
+      LOG ("clause is reason forcing %d", forced);
+      assert (var (forced).level);
+      backtrack (var (forced).level - 1);
+    }
+
+    // As long the (remaining) literals of the sorted clause match
+    // decisions on the trail we just reuse them.
+    //
+    if (level) {
+
+      int l = 1;        // This is the decision level we want to reuse.
+
+      for (const auto & lit : sorted) {
+	if (fixed (lit)) continue;
+	const int decision = control[l].decision;
+	if (-lit == decision) {
+	  LOG ("reusing decision %d at decision level %d", decision, l);
+	  stats.vivifyreused++;
+	  if (++l > level) break;
+	} else {
+	  LOG ("literal %d does not match decision %d at decision level %d",
+	    lit, decision, l);
+	  backtrack (l-1);
+	  break;
+	}
+      }
+    }
+
+    LOG ("reused %d decision levels from %d", level, orig_level);
+  }
+
+  LOG (sorted, "sorted size %zd probing schedule", sorted.size ());
+
+  // Make sure to ignore this clause during propagation.  This is not that
+  // easy for binary clauses (NO-BINARY), e.g., ignoring binary clauses,
+  // without changing 'propagate'. Actually, we do not want to remove binary
+  // clauses which are subsumed.  Those are hyper binary resolvents and
+  // should be kept as learned clauses instead, unless they are transitive
+  // in the binary implication graph, which in turn is detected during
+  // transitive reduction in 'transred'.
+  //
+  ignore = c;
+
+  int subsume = 0;            // determined to be redundant / subsumed
+  int remove = 0;             // at least literal 'remove' can be removed
+
+  // If the candidate is redundant, i.e., we are in redundant mode, the
+  // clause is subsumed (in one of the two cases below where 'subsume' is
+  // assigned) and further all reasons involved are only binary clauses,
+  // then this redundant clause is what we once called a hidden tautology,
+  // and even for redundant clauses it makes sense to remove the candidate.
+  // It does not add anything to propagation power of the formula.  This is
+  // the same argument as removing transitive clauses in the binary
+  // implication graph during transitive reduction.
+  //
+  bool only_binary_reasons = false;
+
+  // Go over the literals in the candidate clause in sorted order.
+  //
+  for (const auto & lit : sorted) {
+
+    // Exit loop as soon a literal is positively implied (case '@5' below)
+    // or propagation of the negation of a literal fails ('@6').
+    //
+    if (subsume) break;
+
+    // We keep on assigning literals, even though we know already that we
+    // can remove one (was negatively implied), since we either might run
+    // into the 'subsume' case above or more false literals become implied.
+    // In any case this might result in stronger vivified clauses.  As a
+    // consequence continue with this loop even if 'remove' is non-zero.
+
+    const signed char tmp = val (lit);
+
+    if (tmp) {                // literal already assigned
+
+      const Var & v = var (lit);
+
+      if (!v.level) { LOG ("skipping fixed %d", lit); continue; }
+      if (!v.reason) { LOG ("skipping decision %d", lit); continue; }
+
+      if (tmp > 0) {          // positively implied
+
+        LOG ("subsumed since literal %d already true", lit);
+
+        subsume = lit;        // will be able to subsume candidate '@5'
+
+        // In redundant mode we want to strengthen clauses instead of
+        // subsuming them (actually incorrect for irredundant candidates).
+        // Thus we perform resolutions to find such a strengthening.
+        //
+        if (redundant_mode) {
+
+          assert (c->redundant);
+          assert (clause.empty ());
+          assert (analyzed.empty ());
+
+          // We start the analysis by adding the negation of the implied
+          // literal to the global 'clause'.
+          //
+          flags (lit).seen = true;
+          analyzed.push_back (-lit);
+          LOG ("vivify seen %d", -lit);
+          assert (v.reason);
+
+          // Continue the analysis with the reason of the implied literal.
+          //
+          vivify_analyze_redundant (vivifier, v.reason, only_binary_reasons);
+          if (!only_binary_reasons) {
+            vivify_post_process_analysis (c, subsume);
+            if (!clause.empty ()) stats.vivifystred2++;
+          }
+          clear_analyzed_literals ();
+
+          backtrack (level - 1);
+          assert (!conflict);
+
+          break;
+        }
+
+      } else {                // negatively implied
+
+        assert (tmp < 0);
+        LOG ("literal %d is already false and can be removed", lit);
+
+        remove = lit;         // will be able to remove this literal
+      }
+
+    } else {                  // still unassigned
+
+      stats.vivifydecs++;
+      vivify_assume (-lit);
+      LOG ("negated decision %d score %" PRId64 "", lit, noccs (lit));
+
+      if (vivify_propagate ()) continue;        // hot-spot
+
+      LOG ("subsumed since propagation produced conflict");
+
+      subsume = INT_MIN;      // will be able to subsume candidate '@6'
+
+      // Again try to strengthen instead of subsuming in redundant mode.
+      //
+      if (redundant_mode) {
+
+        assert (c->redundant);
+        assert (clause.empty ());
+        assert (analyzed.empty ());
+
+        vivify_analyze_redundant (vivifier, conflict, only_binary_reasons);
+        if (!only_binary_reasons) {
+          vivify_post_process_analysis (c, subsume);
+          if (!clause.empty ()) stats.vivifystred3++;
+        }
+        clear_analyzed_literals ();
+      }
+
+      backtrack (level - 1);
+      conflict = 0;
+
+      break;
+    }
+  }
+
+  assert (ignore == c);
+  ignore = 0;
+
+  if (subsume) {
+
+    if (redundant_mode && !only_binary_reasons) {
+
+      assert (c->redundant);
+
+      if (!clause.empty ()) {
+
+        LOG ("strengthening instead of subsuming clause");
+        vivify_strengthen (c);
+
+      } else {  // triggered by '@7'
+
+        // In redundant mode, where candidates might be redundant and we
+        // allow to propagate over redundant clauses too, we do not remove
+        // unit implied clauses which we failed to strengthen.
+
+        LOG (c, "ignoring asymmetric tautology in redundant mode");
+
+        if (c->redundant) {
+
+          assert (redundant_mode);
+          assert (!c->vivify);
+
+        } else {
+
+          // For an irredundant clause the situation is different, since we
+          // might be able to remove it even if we only propagate over
+          // irredundant clauses.  Thus we schedule it again.
+
+          LOG (c, "rescheduling for irredundant round");
+          assert (!c->vivify);
+
+          c->vivify = true;
+        }
+      }
+
+    } else {
+
+      stats.vivifysubs++;
+      LOG (c, "redundant asymmetric tautology");
+      mark_garbage (c);
+
+    }
+
+  } else if (remove) {
+
+    assert (level);
+    assert (clause.empty ());
+
+    // There might be other literals implied to false (or even root level
+    // falsified).  Those should be removed in addition to 'remove'.
+    //
+    for (const auto & other : *c) {
+      assert (val (other) < 0);
+      Var & v = var (other);
+      if (!v.level) continue; // Remove root-level fixed literals.
+      if (v.reason) {         // Remove all negative implied literals.
+        assert (v.level);
+        assert (v.reason);
+        LOG ("flushing literal %d", other);
+      } else {                                // Decision or unassigned.
+        LOG ("keeping literal %d", other);
+        clause.push_back (other);
+      }
+    }
+
+    if (redundant_mode) stats.vivifystred1++;
+    else                stats.vivifystrirr++;
+
+    vivify_strengthen (c);
+
+  } else {
+    LOG ("vivification failed");
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// There are two modes of vivification, one using all clauses and one
+// focusing on irredundant clauses only.  The latter variant working on
+// irredundant clauses only can also remove irredundant asymmetric
+// tautologies (clauses subsumed through unit propagation), which in
+// redundant mode is incorrect (due to propagating over redundant clauses).
+
+void Internal::vivify_round (bool redundant_mode, int64_t propagation_limit) {
+
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
+
+  PHASE ("vivify", stats.vivifications,
+    "starting %s vivification round propagation limit %" PRId64 "",
+    redundant_mode ? "redundant" : "irredundant", propagation_limit);
+
+  // Disconnect all watches since we sort literals within clauses.
+  //
+  if (watching ()) clear_watches ();
+
+  // Count the number of occurrences of literals in all clauses,
+  // particularly binary clauses, which are usually responsible
+  // for most of the propagations.
+  //
+  init_noccs ();
+
+  for (const auto & c : clauses) {
+
+    if (!consider_to_vivify_clause (c, redundant_mode)) continue;
+
+    // This computes an approximation of the Jeroslow Wang heuristic score
+    //
+    //       nocc (L) =     sum       2^(12-|C|)
+    //                   L in C in F
+    //
+    // but we cap the size at 12, that is all clauses of size 12 and larger
+    // contribute '1' to the score, which allows us to use 'long' numbers.
+    // See the example above (search for '@1').
+    //
+    const int shift = 12 - c->size;
+    const int64_t score = shift < 1 ? 1 : (1l << shift);           // @4
+
+    for (const auto lit : *c)
+      noccs (lit) += score;
+  }
+
+  // Refill the schedule every time.  Unchecked clauses are 'saved' by
+  // setting their 'vivify' bit, such that they can be tried next time.
+  //
+  Vivifier vivifier (redundant_mode);
+
+  // In the first round of filling the schedule check whether there are
+  // still clauses left, which were scheduled but have not been vivified yet.
+  // The second round is only entered if no such clause was found in the
+  // first round.  Then the second round selects all clauses.
+  //
+  for (const auto & c : clauses) {
+
+    if (c->size == 2) continue;       // see also (NO-BINARY) above
+
+    if (!consider_to_vivify_clause (c, redundant_mode)) continue;
+
+    // Literals in scheduled clauses are sorted with their highest score
+    // literals first (as explained above in the example at '@2').  This
+    // is also needed in the prefix subsumption checking below.
+    //
+    sort (c->begin (), c->end (), vivify_more_noccs (this));
+
+    vivifier.schedule.push_back (c);
+  }
+  shrink_vector (vivifier.schedule);
+
+  // Flush clauses subsumed by another clause with the same prefix, which
+  // also includes flushing syntactically identical clauses.
+  //
+  flush_vivification_schedule (vivifier);
+
+  // Sort candidates, with first to be tried candidate clause last, i.e.,
+  // many occurrences and high score literals) as in the example explained
+  // above (search for '@3').
+  //
+  stable_sort (vivifier.schedule.begin (), vivifier.schedule.end (),
+    vivify_clause_later (this));
+
+  // Remember old values of counters to summarize after each round with
+  // verbose messages what happened in that round.
+  //
+  int64_t checked      = stats.vivifychecks;
+  int64_t subsumed     = stats.vivifysubs;
+  int64_t strengthened = stats.vivifystrs;
+  int64_t units        = stats.vivifyunits;
+
+  int64_t scheduled = vivifier.schedule.size ();
+  stats.vivifysched += scheduled;
+
+  PHASE ("vivify", stats.vivifications,
+    "scheduled %" PRId64 " clauses to be vivified %.0f%%",
+    scheduled, percent (scheduled, stats.current.irredundant));
+
+  // Limit the number of propagations during vivification as in 'probe'.
+  //
+  const int64_t limit = stats.propagations.vivify + propagation_limit;
+
+  connect_watches (!redundant_mode);       // watch all relevant clauses
+
+  if (!unsat && !propagate ()) {
+    LOG ("propagation after connecting watches in inconsistency");
+    learn_empty_clause ();
+  }
+
+  while (!unsat &&
+         !terminated_asynchronously () &&
+         !vivifier.schedule.empty () &&
+         stats.propagations.vivify < limit) {
+    Clause * c = vivifier.schedule.back ();              // Next candidate.
+    vivifier.schedule.pop_back ();
+    vivify_clause (vivifier, c);
+  }
+
+  if (level) backtrack ();
+
+  if (!unsat) {
+
+    reset_noccs ();
+
+    int64_t still_need_to_be_vivified = 0;
+    for (const auto & c : vivifier.schedule)
+      if (c->vivify)
+        still_need_to_be_vivified++;
+
+    // Preference clauses scheduled but not vivified yet next time.
+    //
+    if (still_need_to_be_vivified)
+      PHASE ("vivify", stats.vivifications,
+        "still need to vivify %" PRId64 " clauses %.02f%% of %" PRId64
+        " scheduled", still_need_to_be_vivified,
+        percent (still_need_to_be_vivified, scheduled),
+        scheduled);
+    else {
+      PHASE ("vivify", stats.vivifications,
+        "no previously not yet vivified clause left");
+      for (const auto & c : vivifier.schedule)
+        c->vivify = true;
+    }
+
+    vivifier.erase ();          // Reclaim  memory early.
+  }
+
+  clear_watches ();
+  connect_watches ();
+
+  if (!unsat) {
+
+    // Since redundant clause were disconnected during propagating vivified
+    // units in redundant mode, and further irredundant clauses are
+    // arbitrarily sorted, we have to propagate all literals again after
+    // connecting the first two literals in the clauses, in order to
+    // reestablish the watching invariant.
+    //
+    propagated2 = propagated = 0;
+
+    if (!propagate ()) {
+      LOG ("propagating vivified units leads to conflict");
+      learn_empty_clause ();
+    }
+  }
+
+  checked      = stats.vivifychecks - checked;
+  subsumed     = stats.vivifysubs   - subsumed;
+  strengthened = stats.vivifystrs   - strengthened;
+  units        = stats.vivifyunits  - units;
+
+  PHASE ("vivify", stats.vivifications,
+    "checked %" PRId64 " clauses %.02f%% of %" PRId64 " scheduled",
+    checked, percent (checked, scheduled), scheduled);
+  if (units)
+    PHASE ("vivify", stats.vivifications,
+      "found %" PRId64 " units %.02f%% of %" PRId64 " checked",
+      units, percent (units, checked), checked);
+  if (subsumed)
+    PHASE ("vivify", stats.vivifications,
+      "subsumed %" PRId64 " clauses %.02f%% of %" PRId64 " checked",
+      subsumed, percent (subsumed, checked), checked);
+  if (strengthened)
+    PHASE ("vivify", stats.vivifications,
+      "strengthened %" PRId64 " clauses %.02f%% of %" PRId64 " checked",
+      strengthened, percent (strengthened, checked), checked);
+
+  stats.subsumed     += subsumed;
+  stats.strengthened += strengthened;
+
+  last.vivify.propagations = stats.propagations.search;
+
+  bool unsuccessful = !(subsumed + strengthened + units);
+  report (redundant_mode ? 'w' : 'v', unsuccessful);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::vivify () {
+
+  if (unsat) return;
+  if (terminated_asynchronously ()) return;
+  if (!stats.current.irredundant) return;
+
+  assert (opts.vivify);
+  assert (!level);
+
+  START_SIMPLIFIER (vivify, VIVIFY);
+  stats.vivifications++;
+
+  int64_t limit = stats.propagations.search;
+  limit -= last.vivify.propagations;
+  limit *= 1e-3 * opts.vivifyreleff;
+  if (limit < opts.vivifymineff) limit = opts.vivifymineff;
+  if (limit > opts.vivifymaxeff) limit = opts.vivifymaxeff;
+
+  PHASE ("vivify", stats.vivifications,
+    "vivification limit of twice %" PRId64 " propagations", limit);
+
+  vivify_round (false, limit); // Vivify only irredundant clauses.
+
+  limit *= 1e-3 * opts.vivifyredeff;
+
+  vivify_round (true, limit);  // Vivify all clauses.
+
+  STOP_SIMPLIFIER (vivify, VIVIFY);
+
+  last.vivify.propagations = stats.propagations.search;
+}
+
+}
diff --git a/hCaD_V2/src/vivify.hpp b/hCaD_V2/src/vivify.hpp
new file mode 100644
index 0000000..05b2538
--- /dev/null
+++ b/hCaD_V2/src/vivify.hpp
@@ -0,0 +1,23 @@
+#ifndef _vivify_hpp_INCLUDED
+#define _vivify_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Clause;
+
+struct Vivifier {
+  vector<Clause *> schedule, stack;
+  vector<int> sorted;
+  bool redundant_mode;
+  Vivifier (bool mode) : redundant_mode (mode) { }
+
+  void erase () {
+    erase_vector (schedule);
+    erase_vector (sorted);
+    erase_vector (stack);
+  }
+};
+
+}
+
+#endif
diff --git a/hCaD_V2/src/walk.cpp b/hCaD_V2/src/walk.cpp
new file mode 100644
index 0000000..bbda837
--- /dev/null
+++ b/hCaD_V2/src/walk.cpp
@@ -0,0 +1,667 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Random walk local search based on 'ProbSAT' ideas.
+
+struct Walker {
+
+  Internal * internal;
+
+  Random random;                // local random number generator
+  int64_t propagations;         // number of propagations
+  int64_t limit;                // limit on number of propagations
+  vector <Clause *> broken;     // currently unsatisfied clauses
+  double epsilon;               // smallest considered score
+  vector<double> table;         // break value to score table
+  vector<double> scores;        // scores of candidate literals
+
+  double score (unsigned);      // compute score from break count
+
+  Walker (Internal *, double size, int64_t limit);
+};
+
+// These are in essence the CB values from Adrian Balint's thesis.  They
+// denote the inverse 'cb' of the base 'b' of the (probability) weight
+// 'b^-i' for picking a literal with the break value 'i' (first column is
+// the 'size', second the 'CB' value).
+
+static double cbvals[][2] = {
+  { 0.0, 2.00 },
+  { 3.0, 2.50 },
+  { 4.0, 2.85 },
+  { 5.0, 3.70 },
+  { 6.0, 5.10 },
+  { 7.0, 7.40 },        // Adrian has '5.4', but '7.4' looks better.
+};
+
+static const int ncbvals = sizeof cbvals / sizeof cbvals[0];
+
+// We interpolate the CB values for uniform random SAT formula to the non
+// integer situation of average clause size by piecewise linear functions.
+//
+//   y2 - y1
+//   ------- * (x - x1) + y1
+//   x2 - x1
+//
+// where 'x' is the average size of clauses and 'y' the CB value.
+
+inline static double fitcbval (double size) {
+  int i = 0;
+  while (i+2 < ncbvals && (cbvals[i][0] > size || cbvals[i+1][0] < size))
+    i++;
+  const double x2 = cbvals[i+1][0], x1 = cbvals[i][0];
+  const double y2 = cbvals[i+1][1], y1 = cbvals[i][1];
+  const double dx = x2 - x1, dy = y2 - y1;
+  assert (dx);
+  const double res = dy * (size - x1) / dx + y1;
+  assert (res > 0);
+  return res;
+}
+
+// Initialize the data structures for one local search round.
+
+Walker::Walker (Internal * i, double size, int64_t l) :
+  internal (i),
+  random (internal->opts.seed),         // global random seed
+  propagations (0),
+  limit (l)
+{
+  random += internal->stats.walk.count; // different seed every time
+
+  // This is the magic constant in ProbSAT (also called 'CB'), which we pick
+  // according to the average size every second invocation and otherwise
+  // just the default '2.0', which turns into the base '0.5'.
+  //
+  const bool use_size_based_cb = (internal->stats.walk.count & 1);
+  const double cb = use_size_based_cb ? fitcbval (size) : 2.0;
+  assert (cb);
+  const double base = 1/cb;     // scores are 'base^0,base^1,base^2,...
+
+  double next = 1;
+  for (epsilon = next; next; next = epsilon*base)
+    table.push_back (epsilon = next);
+
+  PHASE ("walk", internal->stats.walk.count,
+    "CB %.2f with inverse %.2f as base and table size %zd",
+    cb, base, table.size ());
+}
+
+// The scores are tabulated for faster computation (to avoid 'pow').
+
+inline double Walker::score (unsigned i) {
+  const double res = (i < table.size () ? table[i] : epsilon);
+  LOG ("break %u mapped to score %g", i, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+Clause * Internal::walk_pick_clause (Walker & walker) {
+  require_mode (WALK);
+  assert (!walker.broken.empty ());
+  int64_t size = walker.broken.size ();
+  if (size > INT_MAX) size = INT_MAX;
+  int pos = walker.random.pick_int (0, size-1);
+  Clause * res = walker.broken[pos];
+  LOG (res, "picking random position %d", pos);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Compute the number of clauses which would be become unsatisfied if 'lit'
+// is flipped and set to false.  This is called the 'break-count' of 'lit'.
+
+unsigned Internal::walk_break_value (int lit) {
+
+  require_mode (WALK);
+  assert (val (lit) > 0);
+
+  unsigned res = 0;             // The computed break-count of 'lit'.
+
+  for (auto & w : watches (lit)) {
+    assert (w.blit != lit);
+    if (val (w.blit) > 0) continue;
+    if (w.binary ()) { res++; continue; }
+
+    Clause * c = w.clause;
+    assert (lit == c->literals[0]);
+
+    // Now try to find a second satisfied literal starting at 'literals[1]'
+    // shifting all the traversed literals to right by one position in order
+    // to move such a second satisfying literal to 'literals[1]'.  This move
+    // to front strategy improves the chances to find the second satisfying
+    // literal earlier in subsequent break-count computations.
+    //
+    auto begin = c->begin () + 1;
+    const auto end = c->end ();
+    auto i = begin;
+    int prev = 0;
+    while (i != end) {
+      const int other = *i;
+      *i++ = prev;
+      prev = other;
+      if (val (other) < 0) continue;
+
+      // Found 'other' as second satisfying literal.
+
+      w.blit = other;                   // Update 'blit'
+      *begin = other;                   // and move to front.
+
+      break;
+    }
+
+    if (i != end) continue;     // Double satisfied!
+
+    // Otherwise restore literals (undo shift to the right).
+    //
+    while (i != begin) {
+      const int other = *--i;
+      *i = prev;
+      prev = other;
+    }
+
+    res++;      // Literal 'lit' single satisfies clause 'c'.
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Given an unsatisfied clause 'c', in which we want to flip a literal, we
+// first determine the exponential score based on the break-count of its
+// literals and then sample the literals based on these scores.  The CB
+// value is smaller than one and thus the score is exponentially decreasing
+// with the break-count increasing.  The sampling works as in 'ProbSAT' and
+// 'YalSAT' by summing up the scores and then picking a random limit in the
+// range of zero to the sum, then summing up the scores again and picking
+// the first literal which reaches the limit.  Note, that during incremental
+// SAT solving we can not flip assumed variables.  Those are assigned at
+// decision level one, while the other variables are assigned at two.
+
+int Internal::walk_pick_lit (Walker & walker, Clause * c) {
+  LOG ("picking literal by break-count");
+  assert (walker.scores.empty ());
+  double sum = 0;
+  int64_t propagations = 0;
+  for (const auto lit : *c) {
+    assert (active (lit));
+    if (var (lit).level == 1) {
+      LOG ("skipping assumption %d for scoring", -lit);
+      continue;
+    }
+    assert (active (lit));
+    propagations++;
+    unsigned tmp = walk_break_value (-lit);
+    double score = walker.score (tmp);
+    LOG ("literal %d break-count %u score %g", lit, tmp, score);
+    walker.scores.push_back (score);
+    sum += score;
+  }
+  LOG ("scored %zd literals", walker.scores.size ());
+  assert (!walker.scores.empty ());
+  walker.propagations += propagations;
+  stats.propagations.walk += propagations;
+  assert (walker.scores.size () <= (size_t) c->size);
+  const double lim = sum * walker.random.generate_double ();
+  LOG ("score sum %g limit %g", sum, lim);
+  const auto end = c->end ();
+  auto i = c->begin ();
+  auto j = walker.scores.begin ();
+  int res;
+  for (;;) {
+    assert (i != end);
+    res = *i++;
+    if (var (res).level > 1) break;
+    LOG ("skipping assumption %d without score", -res);
+  }
+  sum = *j++;
+  while (sum <= lim && i != end) {
+    res = *i++;
+    if (var (res).level == 1) {
+      LOG ("skipping assumption %d without score", -res);
+      continue;
+    }
+    sum += *j++;
+  }
+  walker.scores.clear ();
+  LOG ("picking literal %d by break-count", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::walk_flip_lit (Walker & walker, int lit) {
+
+  require_mode (WALK);
+  LOG ("flipping assign %d", lit);
+  assert (val (lit) < 0);
+
+  // First flip the literal value.
+  //
+  const int tmp = sign (lit);
+  const int idx = abs (lit);
+  vals[idx] = tmp;
+  vals[-idx] = -tmp;
+  assert (val (lit) > 0);
+
+  // Then remove 'c' and all other now satisfied (made) clauses.
+  {
+    // Simply go over all unsatisfied (broken) clauses.
+
+    LOG ("trying to make %zd broken clauses", walker.broken.size ());
+
+    // We need to measure (and bound) the memory accesses during traversing
+    // broken clauses in terms of 'propagations'. This is tricky since we
+    // are not actually propagating literals.  Instead we use the clause
+    // variable 'ratio' as an approximation to the number of clauses used
+    // during propagating a literal.  Note that we use a one-watch scheme.
+    // Accordingly the number of broken clauses traversed divided by that
+    // ratio is an approximation of the number of propagation this would
+    // correspond to (in terms of memory access).  To eagerly update these
+    // statistics we simply increment the propagation counter after every
+    // 'ratio' traversed clause.  These propagations are particularly
+    // expensive if the number of broken clauses is large which usually
+    // happens initially.
+    //
+    const double ratio = clause_variable_ratio ();
+    const auto eou = walker.broken.end ();
+    auto j = walker.broken.begin (), i = j;
+    int64_t made = 0, count = 0;
+
+    while (i != eou) {
+
+      Clause * d = *j++ = *i++;
+
+      int * literals = d->literals, prev = 0;
+
+      // Find 'lit' in 'd'.
+      //
+      const int size = d->size;
+      for (int i = 0; i < size; i++) {
+        const int other = literals[i];
+        assert (active (other));
+        literals[i] = prev;
+        prev = other;
+        if (other == lit) break;
+        assert (val (other) < 0);
+      }
+
+      // If 'lit' is in 'd' then move it to the front to watch it.
+      //
+      if (prev == lit) {
+        literals[0] = lit;
+        LOG (d, "made");
+        watch_literal (literals[0], literals[1], d);
+        made++;
+        j--;
+
+      } else {  // Otherwise the clause is not satisfied, undo shift.
+
+        for (int i = size-1; i >= 0; i--) {
+          int other = literals[i];
+          literals[i] = prev;
+          prev = other;
+        }
+      }
+
+      if (count--) continue;
+
+      // Update these counters eagerly.  Otherwise if we delay the update
+      // until all clauses are traversed, interrupting the solver has a high
+      // chance of giving bogus statistics on the number of 'propagations'
+      // in 'walk', if it is interrupted in this loop.
+
+      count = ratio;                    // Starting counting down again.
+      walker.propagations++;
+      stats.propagations.walk++;
+    }
+    LOG ("made %" PRId64 " clauses by flipping %d", made, lit);
+    walker.broken.resize (j - walker.broken.begin ());
+  }
+
+  // Finally add all new unsatisfied (broken) clauses.
+  {
+    walker.propagations++;      // This really corresponds now to one
+    stats.propagations.walk++;  // propagation (in a one-watch scheme).
+
+    int64_t broken = 0;
+    Watches & ws = watches (-lit);
+
+    LOG ("trying to brake %zd watched clauses", ws.size ());
+
+    for (const auto w : ws) {
+      Clause * d = w.clause;
+      LOG (d, "unwatch %d in", -lit);
+      int * literals = d->literals, replacement = 0, prev = -lit;
+      assert (literals[0] == -lit);
+      const int size = d->size;
+      for (int i = 1; i < size; i++) {
+        const int other = literals[i];
+        assert (active (other));
+        literals[i] = prev;             // shift all to right
+        prev = other;
+        const signed char tmp = val (other);
+        if (tmp < 0) continue;
+        replacement = other;            // satisfying literal
+        break;
+      }
+      if (replacement) {
+        literals[1] = -lit;
+        literals[0] = replacement;
+        assert (-lit != replacement);
+        watch_literal (replacement, -lit, d);
+      } else {
+        for (int i = size-1; i > 0; i--) {      // undo shift
+          const int other = literals[i];
+          literals[i] = prev;
+          prev = other;
+        }
+        assert (literals[0] == -lit);
+        LOG (d, "broken");
+        walker.broken.push_back (d);
+        broken++;
+      }
+    }
+    LOG ("broken %" PRId64 " clauses by flipping %d", broken, lit);
+    ws.clear ();
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether to save the current phases as new global minimum.
+
+inline void Internal::walk_save_minimum (Walker & walker) {
+  int64_t broken = walker.broken.size ();
+  if (broken >= stats.walk.minimum) return;
+  VERBOSE (3, "new global minimum %" PRId64 "", broken);
+  stats.walk.minimum = broken;
+  for (auto i : vars) {
+    const signed char tmp = vals[i];
+    if (tmp)
+      phases.min[i] = phases.saved[i] = tmp;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::walk_round (int64_t limit, bool prev) {
+
+  backtrack ();
+  if (propagated < trail.size () && !propagate ()) {
+    LOG ("empty clause after root level propagation");
+    learn_empty_clause ();
+    return 20;
+  }
+
+  stats.walk.count++;
+
+  clear_watches ();
+
+  // Remove all fixed variables first (assigned at decision level zero).
+  //
+  if (last.collect.fixed < stats.all.fixed)
+    garbage_collection ();
+
+#ifndef QUIET
+  // We want to see more messages during initial local search.
+  //
+  if (localsearching) {
+    assert (!force_phase_messages);
+    force_phase_messages = true;
+  }
+#endif
+
+  PHASE ("walk", stats.walk.count,
+    "random walk limit of %" PRId64 " propagations", limit);
+
+  // First compute the average clause size for picking the CB constant.
+  //
+  double size = 0;
+  int64_t n = 0;
+  for (const auto c : clauses) {
+    if (c->garbage) continue;
+    if (c->redundant) {
+      if (!opts.walkredundant) continue;
+      if (!likely_to_be_kept_clause (c)) continue;
+    }
+    size += c->size;
+    n++;
+  }
+  double average_size = relative (size, n);
+
+  PHASE ("walk", stats.walk.count,
+    "%" PRId64 " clauses average size %.2f over %d variables",
+    n, average_size, active ());
+
+  // Instantiate data structures for this local search round.
+  //
+  Walker walker (internal, average_size, limit);
+
+  bool failed = false;  // Inconsistent assumptions?
+
+  level = 1;    // Assumed variables assigned at level 1.
+
+  if (assumptions.empty ()) {
+    LOG ("no assumptions so assigning all variables to decision phase");
+  } else {
+    LOG ("assigning assumptions to their forced phase first");
+    for (const auto lit : assumptions) {
+      signed char tmp = val (lit);
+      if (tmp > 0) continue;
+      if (tmp < 0) {
+        LOG ("inconsistent assumption %d", lit);
+        failed = true;
+        break;
+      }
+      if (!active (lit)) continue;
+      tmp = sign (lit);
+      const int idx = abs (lit);
+      LOG ("initial assign %d to assumption phase", tmp < 0 ? -idx : idx);
+      vals[idx] = tmp;
+      vals[-idx] = -tmp;
+      assert (level == 1);
+      var (idx).level = 1;
+    }
+    if (!failed)
+      LOG ("now assigning remaining variables to their decision phase");
+  }
+
+  level = 2;    // All other non assumed variables assigned at level 2.
+
+  if (!failed) {
+
+    for (auto idx : vars) {
+      if (!active (idx)) {
+        LOG ("skipping inactive variable %d", idx);
+        continue;
+      }
+      if (vals[idx]) {
+        assert (var (idx).level == 1);
+        LOG ("skipping assumed variable %d", idx);
+        continue;
+      }
+      int tmp = 0;
+      if (prev) tmp = phases.prev[idx];
+      if (!tmp) tmp = sign (decide_phase (idx, true));
+      assert (tmp == 1 || tmp == -1);
+      vals[idx] = tmp;
+      vals[-idx] = -tmp;
+      assert (level == 2);
+      var (idx).level = 2;
+      LOG ("initial assign %d to decision phase", tmp < 0 ? -idx : idx);
+    }
+
+    LOG ("watching satisfied and registering broken clauses");
+#ifdef LOGGING
+    int64_t watched = 0;
+#endif
+    for (const auto c : clauses) {
+
+      if (c->garbage) continue;
+      if (c->redundant) {
+        if (!opts.walkredundant) continue;
+        if (!likely_to_be_kept_clause (c)) continue;
+      }
+
+      bool satisfiable = false;         // contains not only assumptions
+      int satisfied = 0;                // clause satisfied?
+
+      int * lits = c->literals;
+      const int size = c->size;
+
+      // Move to front satisfied literals and determine whether there
+      // is at least one (non-assumed) literal that can be flipped.
+      //
+      for (int i = 0; satisfied < 2 && i < size; i++) {
+        const int lit = lits[i];
+        assert (active (lit));  // Due to garbage collection.
+        if (val (lit) > 0) {
+          swap (lits[satisfied], lits[i]);
+          if (!satisfied++) LOG ("first satisfying literal %d", lit);
+        } else if (!satisfiable && var (lit).level > 1) {
+          LOG ("non-assumption potentially satisfying literal %d", lit);
+          satisfiable = true;
+        }
+      }
+
+      if (!satisfied && !satisfiable) {
+        LOG (c, "due to assumptions unsatisfiable");
+        LOG ("stopping local search since assumptions falsify a clause");
+        failed = true;
+        break;
+      }
+
+      if (satisfied) {
+        watch_literal (lits[0], lits[1], c);
+#ifdef LOGGING
+        watched++;
+#endif
+      } else {
+        assert (satisfiable);   // at least one non-assumed variable ...
+        LOG (c, "broken");
+        walker.broken.push_back (c);
+      }
+    }
+#ifdef LOGGING
+    if (!failed) {
+      int64_t broken = walker.broken.size ();
+      int64_t total = watched + broken;
+      LOG ("watching %" PRId64 " clauses %.0f%% "
+           "out of %" PRId64 " (watched and broken)",
+        watched, percent (watched, total), total);
+    }
+#endif
+  }
+
+  int64_t old_global_minimum = stats.walk.minimum;
+
+  int res;      // Tells caller to continue with local search.
+
+  if (!failed) {
+
+    int64_t broken = walker.broken.size ();
+
+    PHASE ("walk", stats.walk.count,
+     "starting with %" PRId64 " unsatisfied clauses "
+     "(%.0f%% out of %" PRId64 ")",
+     broken, percent (broken, stats.current.irredundant),
+     stats.current.irredundant);
+
+    walk_save_minimum (walker);
+
+    int64_t flips = 0, minimum = broken;
+    while (!terminated_asynchronously () &&
+           !walker.broken.empty () &&
+           walker.propagations < walker.limit) {
+      flips++;
+      stats.walk.flips++;
+      stats.walk.broken += broken;
+      Clause * c = walk_pick_clause (walker);
+      const int lit = walk_pick_lit (walker, c);
+      walk_flip_lit (walker, lit);
+      broken = walker.broken.size ();
+      LOG ("now have %" PRId64 " broken clauses in total", broken);
+      if (broken >= minimum) continue;
+      minimum = broken;
+      VERBOSE (3,
+        "new phase minimum %" PRId64 " after %" PRId64 " flips",
+        minimum, flips);
+      walk_save_minimum (walker);
+    }
+
+    if (minimum < old_global_minimum)
+      PHASE ("walk", stats.walk.count,
+        "%snew global minimum %" PRId64 "%s in %" PRId64 " flips and "
+        "%" PRId64 " propagations",
+        tout.bright_yellow_code (), minimum, tout.normal_code (),
+        flips, walker.propagations);
+    else
+      PHASE ("walk", stats.walk.count,
+        "best phase minimum %" PRId64 " in %" PRId64 " flips and "
+        "%" PRId64 " propagations",
+        minimum, flips, walker.propagations);
+
+    PHASE ("walk", stats.walk.count,
+      "%.2f million propagations per second",
+      relative (1e-6*walker.propagations,
+      time () - profiles.walk.started));
+
+    PHASE ("walk", stats.walk.count,
+      "%.2f thousand flips per second",
+      relative (1e-3*flips, time () - profiles.walk.started));
+
+    if (minimum > 0) {
+      LOG ("minimum %" PRId64 " non-zero thus potentially continue", minimum);
+      res = 0;
+    } else {
+      LOG ("minimum is zero thus stop local search");
+      res = 10;
+    }
+
+  } else {
+
+    res = 20;
+
+    PHASE ("walk", stats.walk.count,
+      "aborted due to inconsistent assumptions");
+  }
+
+  copy_phases (phases.prev);
+
+  for (auto idx : vars)
+    if (active (idx))
+      vals[idx] = vals[-idx] = 0;
+
+  assert (level == 2);
+  level = 0;
+
+  clear_watches ();
+  connect_watches ();
+
+#ifndef QUIET
+  if (localsearching) {
+    assert (force_phase_messages);
+    force_phase_messages = false;
+  }
+#endif
+
+  return res;
+}
+
+void Internal::walk () {
+  START_INNER_WALK ();
+  int64_t limit = stats.propagations.search;
+  limit *= 1e-3 * opts.walkreleff;
+  if (limit < opts.walkmineff) limit = opts.walkmineff;
+  if (limit > opts.walkmaxeff) limit = opts.walkmaxeff;
+  (void) walk_round (limit, false);
+  STOP_INNER_WALK ();
+}
+
+}
diff --git a/hCaD_V2/src/watch.cpp b/hCaD_V2/src/watch.cpp
new file mode 100644
index 0000000..158b9da
--- /dev/null
+++ b/hCaD_V2/src/watch.cpp
@@ -0,0 +1,100 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::init_watches () {
+  assert (wtab.empty ());
+  while (wtab.size () < 2*vsize)
+    wtab.push_back (Watches ());
+  LOG ("initialized watcher tables");
+}
+
+void Internal::clear_watches () {
+  for (auto lit : lits)
+    watches (lit).clear ();
+}
+
+void Internal::reset_watches () {
+  assert (!wtab.empty ());
+  erase_vector (wtab);
+  LOG ("reset watcher tables");
+}
+
+// This can be quite costly since lots of memory is accessed in a rather
+// random fashion, and thus we optionally profile it.
+
+void Internal::connect_watches (bool irredundant_only) {
+  START (connect);
+  assert (watching ());
+
+  LOG ("watching all %sclauses", irredundant_only ? "irredundant " : "");
+
+  // First connect binary clauses.
+  //
+  for (const auto & c : clauses) {
+    if (irredundant_only && c->redundant) continue;
+    if (c->garbage || c->size > 2) continue;
+    watch_clause (c);
+  }
+
+  // Then connect non-binary clauses.
+  //
+  for (const auto & c : clauses) {
+    if (irredundant_only && c->redundant) continue;
+    if (c->garbage || c->size == 2) continue;
+    watch_clause (c);
+    if (!level) {
+      const int lit0 = c->literals[0];
+      const int lit1 = c->literals[1];
+      const signed char tmp0 = val (lit0);
+      const signed char tmp1 = val (lit1);
+      if (tmp0 > 0) continue;
+      if (tmp1 > 0) continue;
+      if (tmp0 < 0) {
+        const size_t pos0 = var (lit0).trail;
+        if (pos0 < propagated) {
+          propagated = pos0;
+          LOG ("literal %d resets propagated to %zd", lit0, pos0);
+        }
+      }
+      if (tmp1 < 0) {
+        const size_t pos1 = var (lit1).trail;
+        if (pos1 < propagated) {
+          propagated = pos1;
+          LOG ("literal %d resets propagated to %zd", lit1, pos1);
+        }
+      }
+    }
+  }
+
+  STOP (connect);
+}
+
+void Internal::sort_watches () {
+  assert (watching ());
+  LOG ("sorting watches");
+  Watches saved;
+  for (auto lit : lits) {
+    Watches & ws = watches (lit);
+
+    const const_watch_iterator end = ws.end ();
+    watch_iterator j = ws.begin ();
+    const_watch_iterator i;
+
+    assert (saved.empty ());
+
+    for (i = j; i != end; i++) {
+      const Watch w = *i;
+      if (w.binary ()) *j++ = w;
+      else saved.push_back (w);
+    }
+    ws.resize (j - ws.begin ());
+
+    for (const auto & w : saved)
+      ws.push_back (w);
+
+    saved.clear ();
+  }
+}
+
+}
diff --git a/hCaD_V2/src/watch.hpp b/hCaD_V2/src/watch.hpp
new file mode 100644
index 0000000..0b8a1d8
--- /dev/null
+++ b/hCaD_V2/src/watch.hpp
@@ -0,0 +1,49 @@
+#ifndef _watch_hpp_INCLUDED
+#define _watch_hpp_INCLUDED
+
+#include <cassert>
+#include <vector>
+
+namespace CaDiCaL {
+
+// Watch lists for CDCL search.  The blocking literal (see also comments
+// related to 'propagate') is a must and thus combining that with a 64 bit
+// pointer will give a 16 byte (8 byte aligned) structure anyhow, which
+// means the additional 4 bytes for the size come for free.  As alternative
+// one could use a 32-bit reference instead of the pointer which would
+// however limit the number of clauses to '2^32 - 1'.  One would also need
+// to use at least one more bit (either taken away from the variable space
+// or the clauses) to denote whether the watch is binary.
+
+struct Clause;
+
+struct Watch {
+
+  Clause * clause; int blit;
+  int size;
+
+  Watch (int b, Clause * c) : clause (c), blit (b), size (c->size) { }
+  Watch () { }
+
+  bool binary () const { return size == 2; }
+};
+
+typedef vector<Watch> Watches;          // of one literal
+
+typedef Watches::iterator watch_iterator;
+typedef Watches::const_iterator const_watch_iterator;
+
+inline void remove_watch (Watches & ws, Clause * clause) {
+  const auto end = ws.end ();
+  auto i = ws.begin ();
+  for (auto j = i; j != end; j++) {
+    const Watch & w = *i++ = *j;
+    if (w.clause == clause) i--;
+  }
+  assert (i + 1 == end);
+  ws.resize (i - ws.begin ());
+}
+
+}
+
+#endif
diff --git a/hCaD_V2/starexec_build b/hCaD_V2/starexec_build
new file mode 100644
index 0000000..2c1f8fe
--- /dev/null
+++ b/hCaD_V2/starexec_build
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+./configure --competition
+make
+cp build/cadical ./bin/
diff --git a/hCaD_V2/starexec_description.txt b/hCaD_V2/starexec_description.txt
new file mode 100644
index 0000000..5130943
--- /dev/null
+++ b/hCaD_V2/starexec_description.txt
@@ -0,0 +1 @@
+hCaD V2 is submitted to the CaDiCaL Hack Track
diff --git a/hCaD_V2/test/README.md b/hCaD_V2/test/README.md
new file mode 100644
index 0000000..0d488c0
--- /dev/null
+++ b/hCaD_V2/test/README.md
@@ -0,0 +1,55 @@
+The tests can be executed by `make test` from a configured build,  the `src`
+or `test` directory and will put their intermediate and log files in the
+build directory.  If called from outside from the build directory the last
+configured build directory is used.
+
+We have four test drivers.  The simplest one
+
+    ./api/run.sh
+
+is going through the API directly to test basic stand-alone functionality of
+the library.  Next is a simple usage test for all command line options.
+
+    ./usage/run.sh
+
+The regression suite for CNF files
+
+    ./cnf/run.sh
+
+is more thorough and should catch simple bugs.  It checks solutions and
+checks generated proofs too.  The third test driver uses a regression suite
+and executes traces by replaying them through `mobical`
+
+    ./traces/run.sh
+
+Last but not least the model based tester `../src/mobical.cpp` is the
+most effective test driver and can be run through
+
+    ./mbt/run.sh
+
+All test drivers place their intermediate and logging files into the build
+directory.  Thus if for instance you build in a `release` subdirectory
+within the root directory of CaDiCaL
+
+    mkdir release
+    cd release
+    ../configure
+    make test
+
+will use the library and binaries in this `release` sub-directory for
+running all the tests.  The log files including generated proofs are all put
+into the `release` subdirectory too.
+
+For more information on external fuzz-testing see
+
+> Robert Brummayer, Florian Lonsing, Armin Biere:
+> Automated Testing and Debugging of SAT and QBF Solvers. SAT 2010: 44-57
+
+Model based testing of SAT solvers is described in
+
+> Cyrille Artho, Armin Biere, Martina Seidl:
+> Model-Based Testing for Verification Back-Ends. TAP 2013: 39-55
+
+The simple API test driver and the regression suite are executed by the
+default goal of the `makefile`.  There is no need to clean up test output
+since it is all put into the build directory.
diff --git a/hCaD_V2/test/api/README.md b/hCaD_V2/test/api/README.md
new file mode 100644
index 0000000..ea38b92
--- /dev/null
+++ b/hCaD_V2/test/api/README.md
@@ -0,0 +1,8 @@
+These are unit API tests of the library executed with `run.sh` which
+actually needs to be called from an immediate sub-directory of CaDiCaL.
+
+The binary and results of the tests are put into the build directory.
+
+The `makefile` allows to compile and execute the API tests from within this
+sub-directory with a single `make` command, but then uses `../../build` as
+build directory.
diff --git a/hCaD_V2/test/api/apitrace.cpp b/hCaD_V2/test/api/apitrace.cpp
new file mode 100644
index 0000000..c8b4ba5
--- /dev/null
+++ b/hCaD_V2/test/api/apitrace.cpp
@@ -0,0 +1,77 @@
+#include "../../src/cadical.hpp"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <cstdlib>
+#include <string>
+
+using namespace std;
+using namespace CaDiCaL;
+
+static string path (const char * name) {
+  const char * prefix = getenv ("CADICALBUILD");
+  string res = prefix ? prefix : ".";
+  res += "/test-api-apitrace-";
+  res += name;
+  res += ".trace";
+  return res;
+}
+
+static FILE * trace (const char * name) {
+  return fopen (path (name).c_str (), "w");
+}
+
+int main () {
+
+  {
+    FILE * file = trace ("file1");
+    {
+      Solver solver;
+      solver.trace_api_calls (file);
+    }
+    fclose (file);
+  }
+
+  {
+    setenv ("CADICAL_API_TRACE", path ("environment1").c_str (), 1);
+    {
+      Solver solver;
+      solver.add (1);
+      solver.add (2);
+      solver.add (0);
+      solver.solve ();
+    }
+    unsetenv ("CADICAL_API_TRACE");
+  }
+
+  {
+    FILE * file = trace ("file2");
+    {
+      Solver solver;
+      solver.trace_api_calls (file);
+      solver.add (1);
+      solver.add (0);
+      solver.add (-1);
+      solver.add (0);
+      solver.solve ();
+    }
+    fclose (file);
+  }
+
+  {
+    setenv ("CADICAL_API_TRACE", path ("environment2").c_str (), 1);
+    {
+      Solver solver;
+      solver.add (-1);
+      solver.add (-2);
+      solver.add (0);
+      solver.solve ();
+    }
+    unsetenv ("CADICAL_API_TRACE");
+  }
+
+
+  return 0;
+}
diff --git a/hCaD_V2/test/api/cfreeze.c b/hCaD_V2/test/api/cfreeze.c
new file mode 100644
index 0000000..0747596
--- /dev/null
+++ b/hCaD_V2/test/api/cfreeze.c
@@ -0,0 +1,94 @@
+// Check old freeze/melt semantics.  Example from 'lglib.h' (Lingeling).
+
+#include "../../src/ccadical.h"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+void illegal (void (*f)(CCaDiCaL *, int), CCaDiCaL * cadical, int lit) {
+  pid_t child = fork (), other;
+  int status;
+  if (!child) {
+    int null = open ("/dev/null", O_WRONLY);
+    dup2 (null, 2);
+    f (cadical, lit);
+    close (2);
+    exit (0);
+  }
+  other = wait (&status);
+  assert (other == child);
+  assert (!WIFEXITED (status));
+  assert (WIFSIGNALED (status));
+  assert (WTERMSIG (status) == SIGABRT);
+}
+
+int main () {
+
+  CCaDiCaL * cadical = ccadical_init ();
+  int res;
+
+  ccadical_set_option (cadical, "check", 1);
+  ccadical_set_option (cadical, "checkfrozen", 1);
+
+  ccadical_add (cadical, -14);
+  ccadical_add (cadical, 2);
+  ccadical_add (cadical, 0);                              // binary clause
+
+  ccadical_add (cadical, 14);
+  ccadical_add (cadical, -1);
+  ccadical_add (cadical, 0);                             // binary clause
+
+  ccadical_assume (cadical, 1);                          // assume '1'
+  ccadical_freeze (cadical, 1);                          // will use '1' below
+  ccadical_freeze (cadical, 14);                         // will use '14 too
+  assert (ccadical_frozen (cadical, 1));
+  assert (ccadical_frozen (cadical, 14));
+  res = ccadical_solve (cadical);
+  assert (res == 10);
+  (void) ccadical_val (cadical, 1);                       // fine
+  (void) ccadical_val (cadical, 2);                       // fine
+  (void) ccadical_val (cadical, 3);                       // fine !
+  (void) ccadical_val (cadical, 14);                      // fine
+
+  illegal (ccadical_add, cadical, 2);                     // ILLEGAL
+  illegal (ccadical_assume, cadical, 2);                  // ILLEGAL
+
+  ccadical_add (cadical, -14);
+  ccadical_add (cadical, 1);
+  ccadical_add (cadical, 0);                              // binary clause
+
+  ccadical_add (cadical, 15);
+  ccadical_add (cadical, 0);                              // fine!
+  ccadical_melt (cadical, 14);                            // '1' discarded
+
+  res = ccadical_solve (cadical);
+  assert (res == 10);
+  assert (ccadical_frozen (cadical, 1));
+  (void) ccadical_val (cadical, 1);                       // fine
+  (void) ccadical_val (cadical, 2);                       // fine
+  (void) ccadical_val (cadical, 3);                       // fine
+  (void) ccadical_val (cadical, 14);                      // fine
+  (void) ccadical_val (cadical, 15);                      // fine
+
+  illegal (ccadical_assume, cadical, 2);                  // ILLEGAL
+  illegal (ccadical_assume, cadical, 14);                 // ILLEGAL
+
+  ccadical_add (cadical, 1);                              // still frozen
+  ccadical_melt (cadical, 1);
+  ccadical_add (cadical, 0);
+  res = ccadical_solve (cadical);
+  assert (res == 10);                                     // TODO right?
+  ccadical_reset (cadical);
+
+  return 0;
+}
diff --git a/hCaD_V2/test/api/cipasir.c b/hCaD_V2/test/api/cipasir.c
new file mode 100644
index 0000000..9972731
--- /dev/null
+++ b/hCaD_V2/test/api/cipasir.c
@@ -0,0 +1,114 @@
+#include "../../src/ipasir.h"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+#if __GNUC__ > 4 || defined(__llvm__)
+static const int n = 8;
+#else
+static const int n = 10;
+#endif
+
+static int ph (int p, int h) {
+  assert (0 <= p), assert (p < n + 1);
+  assert (0 <= h), assert (h < n);
+  return 1 + h * (n+1) + p;
+}
+
+// Construct a pigeon hole formula for 'n+1' pigeons in 'n' holes.
+//
+static void formula (void *solver)
+{
+  for (int h = 0; h < n; h++)
+    for (int p1 = 0; p1 < n + 1; p1++)
+      for (int p2 = p1 + 1; p2 < n + 1; p2++)
+	ipasir_add (solver, -ph (p1, h)),
+	ipasir_add (solver, -ph (p2, h)),
+	ipasir_add (solver, 0);
+
+  for (int p = 0; p < n + 1; p++) {
+    for (int h = 0; h < n; h++)
+      ipasir_add (solver, ph (p, h));
+    ipasir_add (solver, 0);
+  }
+}
+
+typedef struct learner learner;
+
+struct learner {
+  void * solver;
+  unsigned learned;
+};
+
+static void learn (void * ptr, int * clause) {
+  learner * learner = ptr;
+  for (const int * p = clause; *p; p++)
+    ipasir_add (learner->solver, *p);
+  ipasir_add (learner->solver, 0);
+  learner->learned++;
+}
+
+static int terminator (void * ptr) { return * (int*) ptr; }
+
+static int terminate;
+
+static void (*saved)(int);
+
+static void handler (int sig) {
+  assert (sig == SIGALRM);
+  signal (SIGALRM, saved);
+  *(volatile int *) & terminate = 1;
+}
+
+static void * solvers[2];
+static learner learners[2];
+
+int main () {
+  printf ("signature '%s'\n", ipasir_signature ());
+  for (int i = 0; i < 2; i++) {
+    learners[i].solver = solvers[i] = ipasir_init ();
+    ipasir_set_learn (solvers[i], learners + !i, 3, learn);
+    formula (solvers[i]);
+  }
+  unsigned round = 0;
+  int active = 0;
+  int res = 0;
+  for (;;) {
+    printf ("round %d active %d imported %u\n",
+            ++round, active, learners[active].learned);
+    fflush (stdout);
+    saved = signal (SIGALRM, handler);
+#if __GNUC__ > 4 || defined(__llvm__)
+    struct timeval value;
+    value.tv_sec = 0;
+    value.tv_usec = 2e4;
+
+    struct timeval interval;
+    interval.tv_sec = 0;
+    interval.tv_usec = 0;
+
+    struct itimerval t;
+    t.it_interval = interval;
+    t.it_value = value;
+    setitimer(0, &t, NULL);
+#else
+    alarm (1);
+#endif
+    ipasir_set_terminate (solvers[active], &terminate, terminator);
+    res = ipasir_solve (solvers[active]);
+    if (res) break;
+    * (volatile int *) &terminate = 0;
+    active = !active;
+  }
+  for (int i = 0; i < 2; i++)
+    ipasir_release (solvers[i]);
+  for (int i = 0; i < 2; i++)
+    printf ("solver[%d] imported %u clauses\n", i, learners[i].learned);
+  return 0;
+}
diff --git a/hCaD_V2/test/api/ctest.c b/hCaD_V2/test/api/ctest.c
new file mode 100644
index 0000000..714e032
--- /dev/null
+++ b/hCaD_V2/test/api/ctest.c
@@ -0,0 +1,30 @@
+#include "../../src/ccadical.h"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+
+int main () {
+  CCaDiCaL * solver = ccadical_init ();
+  int res = ccadical_solve (solver);
+  assert (res == 10);
+  ccadical_add (solver, -1);
+  ccadical_add (solver, 2);
+  ccadical_add (solver, 0);
+  ccadical_add (solver,  1);
+  ccadical_add (solver, 2);
+  ccadical_add (solver, 0);
+  ccadical_add (solver, -1);
+  ccadical_add (solver, -2);
+  ccadical_add (solver, 0);
+  res = ccadical_solve (solver);
+  assert (res == 10);
+  res = ccadical_val (solver, 1);
+  assert (res == -1);
+  res = ccadical_val (solver, 2);
+  assert (res == 2);
+  ccadical_release (solver);
+  return 0;
+}
diff --git a/hCaD_V2/test/api/example.cpp b/hCaD_V2/test/api/example.cpp
new file mode 100644
index 0000000..456e76e
--- /dev/null
+++ b/hCaD_V2/test/api/example.cpp
@@ -0,0 +1,64 @@
+#include "../../src/cadical.hpp"
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <cassert>
+
+// This is the example from the header file
+
+int main () {
+
+ CaDiCaL::Solver * solver = new CaDiCaL::Solver;
+
+ // ------------------------------------------------------------------
+ // Encode Problem and check without assumptions.
+
+ enum { TIE = 1, SHIRT = 2 };
+
+ solver->add (-TIE), solver->add (SHIRT),  solver->add (0);
+ solver->add (TIE),  solver->add (SHIRT),  solver->add (0);
+ solver->add (-TIE), solver->add (-SHIRT), solver->add (0);
+
+ int res = solver->solve ();    // Solve instance.
+ assert (res == 10);            // Check it is 'SATISFIABLE'.
+                               
+ res = solver->val (TIE);       // Obtain assignment of 'TIE'.
+ assert (res < 0);              // Check 'TIE' assigned to 'false'.
+                               
+ res = solver->val (SHIRT);     // Obtain assignment of 'SHIRT'.
+ assert (res > 0);              // Check 'SHIRT' assigned to 'true'.
+                               
+ // ------------------------------------------------------------------
+ // Incrementally solve again under one assumption.
+
+ solver->assume (TIE);          // Now force 'TIE' to true.
+                               
+ res = solver->solve ();        // Solve again incrementally.
+ assert (res == 20);            // Check it is 'UNSATISFIABLE'.
+                               
+ res = solver->failed (TIE);    // Check 'TIE' responsible.
+ assert (res);                  // Yes, 'TIE' in core.
+                               
+ res = solver->failed (SHIRT);  // Check 'SHIRT' responsible.
+ assert (!res);                 // No, 'SHIRT' not in core.
+                               
+ // ------------------------------------------------------------------
+ // Incrementally solve once more under another assumption.
+
+ solver->assume (-SHIRT);       // Now force 'SHIRT' to false.
+                               
+ res = solver->solve ();        // Solve again incrementally.
+ assert (res == 20);            // Check it is 'UNSATISFIABLE'.
+                               
+ res = solver->failed (TIE);    // Check 'TIE' responsible.
+ assert (!res);                 // No, 'TIE' not in core.
+
+ res = solver->failed (-SHIRT); // Check '!SHIRT' responsible.
+ assert (res);                  // Yes, '!SHIRT' in core.
+
+ // ------------------------------------------------------------------
+
+ delete solver;
+
+ return 0;
+}
diff --git a/hCaD_V2/test/api/learn.cpp b/hCaD_V2/test/api/learn.cpp
new file mode 100644
index 0000000..f856d6d
--- /dev/null
+++ b/hCaD_V2/test/api/learn.cpp
@@ -0,0 +1,58 @@
+#include "../../src/cadical.hpp"
+
+#include <iostream>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+extern "C" {
+#include <assert.h>
+}
+
+class Wrapper : CaDiCaL::Learner {
+  CaDiCaL::Solver * solver;
+  std::vector<int> clause;
+public:
+  unsigned clauses;
+  Wrapper (CaDiCaL::Solver * s) : solver (s), clauses (0) { solver->connect_learner (this); }
+  ~Wrapper () { solver->disconnect_learner (); }
+  bool learning (int size) { (void) size; return true; }
+  void learn (int lit) {
+    if (lit) clause.push_back (lit);
+    else {
+      std::cout << "solver[" << ((void*) solver) << "] imported clause of size "
+                << clause.size () << ':';
+      for (auto lit : clause)
+	std::cout << ' ' << lit;
+      std::cout << std::endl << std::flush;
+      clause.clear ();
+      clauses++;
+    }
+  }
+};
+
+static void formula (CaDiCaL::Solver & solver) {
+  for (int r = -1; r < 2; r += 2)
+    for (int s = -1; s < 2; s += 2)
+      for (int t = -1; t < 2; t += 2)
+	solver.add (r * 1), solver.add (s * 2), solver.add (t * 3),
+	solver.add (0);
+}
+
+int main () {
+  CaDiCaL::Solver ping, pong;
+  ping.set ("log", 1), pong.set ("log", 1);
+  Wrapper wing (&ping), wong (&pong);
+  formula (ping), formula (pong);
+  int a = ping.solve ();
+  std::cout << "ping returns " << a << std::endl;
+  std::cout << "wong imported " << wing.clauses << " clauses" << std::endl;
+  int b = pong.solve ();
+  std::cout << "pong returns " << b << std::endl;
+  std::cout << "wing imported " << wing.clauses << " clauses" << std::endl;
+  assert (a == b), assert (a == 20);
+  assert (wing.clauses == wong.clauses);
+  assert (wing.clauses > 3);
+  return 0;
+}
diff --git a/hCaD_V2/test/api/makefile b/hCaD_V2/test/api/makefile
new file mode 100644
index 0000000..9c4f4de
--- /dev/null
+++ b/hCaD_V2/test/api/makefile
@@ -0,0 +1,3 @@
+# compile and execute with a single 'make' the API tests in '../../build'
+test:
+	$(MAKE) -C .. api
diff --git a/hCaD_V2/test/api/morenmore.cpp b/hCaD_V2/test/api/morenmore.cpp
new file mode 100644
index 0000000..16f56ae
--- /dev/null
+++ b/hCaD_V2/test/api/morenmore.cpp
@@ -0,0 +1,20 @@
+#include "../../src/cadical.hpp"
+#include <iostream>
+#include <cassert>
+using namespace std;
+int main () {
+  CaDiCaL::Solver solver;
+  const int n = 100;
+  for (int i = 1; i < n; i++) {
+    for (int j = 1; j < i; j++) solver.add (-j);
+    solver.add (i), solver.add (0);
+  }
+  int res = solver.solve ();
+  assert (res == 10);
+  for (int i = 1; i < n; i++) {
+    res = solver.val (i);
+    assert (res > 0);
+  }
+  (void) res;
+  return 0;
+}
diff --git a/hCaD_V2/test/api/newdelete.cpp b/hCaD_V2/test/api/newdelete.cpp
new file mode 100644
index 0000000..e9adadb
--- /dev/null
+++ b/hCaD_V2/test/api/newdelete.cpp
@@ -0,0 +1,6 @@
+#include "../../src/cadical.hpp"
+int main () {
+  CaDiCaL::Solver * solver = new CaDiCaL::Solver ();
+  delete solver;
+  return 0;
+}
diff --git a/hCaD_V2/test/api/run.sh b/hCaD_V2/test/api/run.sh
new file mode 100644
index 0000000..5ee10e9
--- /dev/null
+++ b/hCaD_V2/test/api/run.sh
@@ -0,0 +1,123 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+die () {
+  cecho "${HIDE}test/api/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  exit 1
+}
+
+msg () {
+  cecho "${HIDE}test/api/run.sh:${NORMAL} $*"
+}
+
+for dir in . .. ../..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+[ -d ../test -a -d ../test/api ] || \
+die "needs to be called from a top-level sub-directory of CaDiCaL"
+
+[ x"$CADICALBUILD" = x ] && CADICALBUILD="../build"
+
+[ -f "$CADICALBUILD/makefile" ] || \
+  die "can not find '$CADICALBUILD/makefile' (run 'configure' first)"
+
+[ -f "$CADICALBUILD/libcadical.a" ] || \
+  die "can not find '$CADICALBUILD/libcadical.a' (run 'make' first)"
+
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "API testing in '$CADICALBUILD'"
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
+
+make -C $CADICALBUILD
+res=$?
+[ $res = 0 ] || exit $res
+
+#--------------------------------------------------------------------------#
+
+makefile=$CADICALBUILD/makefile
+
+CXX=`grep '^CXX=' "$makefile"|sed -e 's,CXX=,,'`
+CXXFLAGS=`grep '^CXXFLAGS=' "$makefile"|sed -e 's,CXXFLAGS=,,'`
+
+msg "using CXX=$CXX"
+msg "using CXXFLAGS=$CXXFLAGS"
+
+tests=../test/api
+
+export CADICALBUILD
+
+#--------------------------------------------------------------------------#
+
+ok=0
+failed=0
+
+cmd () {
+  test $status = 1 && return
+  cecho $*
+  $* >> $name.log
+  status=$?
+}
+
+run () {
+  msg "running API test ${HILITE}'$1'${NORMAL}"
+  if [ -f $tests/$1.c ]
+  then
+    src=$tests/$1.c
+    language=" -x c"
+    COMPILE="$CXX `echo $CXXFLAGS|sed -e 's,-std=c++11,-std=c11,'`"
+  elif [ -f $tests/$1.cpp ]
+  then
+    src=$tests/$1.cpp
+    language=""
+    COMPILE="$CXX $CXXFLAGS"
+  else
+    die "can not find '$tests.c' nor '$tests.cpp'"
+  fi
+  name=$CADICALBUILD/test-api-$1
+  rm -f $name.log $name.o $name
+  status=0
+  cmd $COMPILE$language -o $name.o -c $src
+  cmd $COMPILE -o $name $name.o -L$CADICALBUILD -lcadical
+  cmd $name
+  if test $status = 0
+  then
+    cecho "# 0 ... ${GOOD}ok${NORMAL} (zero exit code)"
+    ok=`expr $ok + 1`
+  else
+    cecho "# 0 ... ${BAD}failed${NORMAL} (non-zero exit code)"
+    failed=`expr $failed + 1`
+  fi
+}
+
+#--------------------------------------------------------------------------#
+
+run newdelete
+run unit
+run morenmore
+run ctest
+run example
+run terminate
+run learn
+run cfreeze
+run traverse
+run cipasir
+
+[ "`grep DNTRACING $makefile`" = "" ] && run apitrace
+
+#--------------------------------------------------------------------------#
+
+[ $ok -gt 0 ] && OK="$GOOD"
+[ $failed -gt 0 ] && FAILED="$BAD"
+
+msg "${HILITE}API testing results:${NORMAL} ${OK}$ok ok${NORMAL}, ${FAILED}$failed failed${NORMAL}"
+
+exit $failed
diff --git a/hCaD_V2/test/api/terminate.cpp b/hCaD_V2/test/api/terminate.cpp
new file mode 100644
index 0000000..0dd5bde
--- /dev/null
+++ b/hCaD_V2/test/api/terminate.cpp
@@ -0,0 +1,49 @@
+#include "../../src/cadical.hpp"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+extern "C" {
+#include <assert.h>
+#include <unistd.h>
+#include <signal.h>
+}
+
+static int n = 11;
+
+static int ph (int p, int h) {
+  assert (0 <= p), assert (p < n + 1);
+  assert (0 <= h), assert (h < n);
+  return 1 + h * (n+1) + p;
+}
+
+static CaDiCaL::Solver solver;
+
+static void handler (int) { solver.terminate (); }
+
+int main () {
+
+  // Construct a pigeon hole formula for 'n+1' pigeons in 'n' holes.
+  //
+  for (int h = 0; h < n; h++)
+    for (int p1 = 0; p1 < n + 1; p1++)
+      for (int p2 = p1 + 1; p2 < n + 1; p2++)
+	solver.add (-ph (p1, h)),
+	solver.add (-ph (p2, h)),
+	solver.add (0);
+
+  for (int p = 0; p < n + 1; p++) {
+    for (int h = 0; h < n; h++)
+      solver.add (ph (p, h));
+    solver.add (0);
+  }
+
+  (void) signal (SIGALRM, handler);
+  ualarm (1e5, 0);
+  int res = solver.solve ();
+  assert (!res);
+  solver.statistics ();
+
+  return 0;
+}
diff --git a/hCaD_V2/test/api/traverse.cpp b/hCaD_V2/test/api/traverse.cpp
new file mode 100644
index 0000000..c4ca00d
--- /dev/null
+++ b/hCaD_V2/test/api/traverse.cpp
@@ -0,0 +1,144 @@
+#include "../../src/cadical.hpp"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+using namespace std;
+using namespace CaDiCaL;
+
+static string path (const char * suffix) {
+  const char * prefix = getenv ("CADICALBUILD");
+  string res = prefix ? prefix : ".";
+  res += "/test-api-traverse.";
+  res += suffix;
+  return res;
+}
+
+struct WitnessChecker : WitnessIterator {
+  bool match (int a, int b) {
+    if (a == -3 && b == 1) return true;
+    if (a == 1 && b == -3) return true;
+    if (a == -3 && b == 2) return true;
+    if (a == 2 && b == -3) return true;
+    return false;
+  }
+  bool match (int a, int b, int c) {
+    if (a == 3 && b == -1 && c == -2) return true;
+    if (a == 3 && b == -2 && c == -1) return true;
+    if (a == -1 && b == 3 && c == -2) return true;
+    if (a == -2 && b == 3 && c == -1) return true;
+    if (a == -1 && b == -2 && c == 3) return true;
+    if (a == -2 && b == -1 && c == 3) return true;
+    return false;
+  }
+public:
+  bool witness (const vector<int> & c, const vector<int> & w) {
+    for (const auto & lit : w) cout << lit << ' ';
+    cout << "0 ";
+    for (const auto & lit : c) cout << lit << ' ';
+    cout << '0' << endl;
+    if (c.size () == 1) {
+      assert (c[0] == 5);
+      assert (w.size () == 1);
+      assert (w[0] == 5);
+    } else {
+      assert (w.size () == 1);
+      assert (w[0] != -3);
+      assert (w[0] != 3);
+      assert (abs (w[0]) == 1 || abs (w[0]) == 2);
+      if (c.size () == 2) assert (match (c[0], c[1]));
+      else assert (c.size () == 3), assert (match (c[0], c[1], c[2]));
+    }
+    return true;
+  }
+};
+
+struct ClauseChecker : ClauseIterator {
+  bool clause (const vector<int> & c) {
+    for (const auto & lit : c) cout << lit << ' ';
+    cout << '0' << endl;
+    assert (c.size () == 1);
+    assert (c[0] == 4);
+    return true;
+  }
+};
+
+int main () {
+
+  Solver cadical;
+
+  // And gate 3 = 1 & 2>
+
+  cadical.add (-3);
+  cadical.add (1);
+  cadical.add (0);
+
+  cadical.add (-3);
+  cadical.add (2);
+  cadical.add (0);
+
+  cadical.add (3);
+  cadical.add (-1);
+  cadical.add (-2);
+  cadical.add (0);
+
+  // Force 4 to true.
+
+  cadical.add (4);
+  cadical.add (1);
+  cadical.add (2);
+  cadical.add (0);
+
+  cadical.add (4);
+  cadical.add (-1);
+  cadical.add (2);
+  cadical.add (0);
+
+  cadical.add (4);
+  cadical.add (1);
+  cadical.add (-2);
+  cadical.add (0);
+
+  cadical.add (4);
+  cadical.add (-1);
+  cadical.add (-2);
+  cadical.add (0);
+
+  // Force 5 to true too.
+
+  cadical.add (5);
+  cadical.add (1);
+  cadical.add (0);
+
+  cadical.add (5);
+  cadical.add (-1);
+  cadical.add (0);
+
+  cadical.freeze (3);
+  cadical.freeze (4);
+
+  cadical.simplify (1);
+
+  // Now we expect '5' to be part of the witness, but '3' and '4' to be part
+  // the traversed clauses and check this too.  See the long comment on
+  // 'frozen' versus 'non-frozen' unit traversal in 'external.cpp'.
+
+  cadical.write_dimacs (path ("clauses").c_str (), 5);
+  cadical.write_extension (path ("extensions").c_str ());
+
+  cout << "clauses" << endl;
+  ClauseChecker clause_checker;
+  cadical.traverse_clauses (clause_checker);
+
+  cout << "witnesses" << endl;
+  WitnessChecker witness_checker;
+  cadical.traverse_witnesses_backward (witness_checker);
+
+  return 0;
+}
diff --git a/hCaD_V2/test/api/unit.cpp b/hCaD_V2/test/api/unit.cpp
new file mode 100644
index 0000000..e8196e1
--- /dev/null
+++ b/hCaD_V2/test/api/unit.cpp
@@ -0,0 +1,22 @@
+#include "../../src/cadical.hpp"
+#include <iostream>
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <cassert>
+using namespace std;
+int main () {
+  CaDiCaL::Solver solver;
+  solver.add (1);
+  solver.add (0);
+  int res = solver.solve ();
+  cout << "solver.solve () = " << res << endl << flush;
+  assert (res == 10);
+  res = solver.val (1);
+  cout << "solver.val (1) = " << res << endl << flush;
+  cout << "solver.val (-1) = " << solver.val (-1) << endl << flush;
+  cout << "solver.val (2) = " << solver.val (2) << endl << flush;
+  cout << "solver.val (3) = " << solver.val (3) << endl << flush;
+  assert (res > 0);
+  return 0;
+}
diff --git a/hCaD_V2/test/cnf/README.md b/hCaD_V2/test/cnf/README.md
new file mode 100644
index 0000000..5b9dfe3
--- /dev/null
+++ b/hCaD_V2/test/cnf/README.md
@@ -0,0 +1,23 @@
+These are CNF files tested with `run.sh` which actually needs to be called
+from an immediate sub-directory of CaDiCaL (such as the directory `..` one
+level up).  Log and proof files are saved in the build directory.
+
+The `.cnf` files are in DIMACS format.
+
+The corresponding `.sol` files are in SAT competition output format and
+provide pre-computed solutions for testing and debugging.
+
+The tool `precochk.c` is used to check witness generated and saved in the
+`.log` files in the build directory to be correct.
+
+The tool `drat-trim.c` is used to check proofs generated and saved in the
+`.prf` files in the build directory to be correct.
+
+We are also testing the `simplifier` flow of CaDiCaL using the scripts
+
+    ../../scripts/run-simplifier-and-extend-solution.sh
+    ../../scripts/extend-solution.sh
+
+The `makefile` allows to execute the CNF tests from within this
+sub-directory with a single `make` command, but always uses `cadical`
+from `../../build/` and also puts the log and error files there.
diff --git a/hCaD_V2/test/cnf/drat-trim.c b/hCaD_V2/test/cnf/drat-trim.c
new file mode 100644
index 0000000..2c34c84
--- /dev/null
+++ b/hCaD_V2/test/cnf/drat-trim.c
@@ -0,0 +1,1610 @@
+/************************************************************************************[drat-trim.c]
+Copyright (c) 2014 Marijn Heule and Nathan Wetzler, The University of Texas at Austin.
+Copyright (c) 2015-2017 Marijn Heule, The University of Texas at Austin.
+Last edit, December 21, 2017
+
+# Minor fixes to have proper exit code for unit testing (Armin Biere)
+# Removed carriage return '\r' printing too (Armin Biere)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <sys/time.h>
+
+#define TIMEOUT     20000
+#define BIGINIT     1000000
+#define INIT        4
+#define END         0
+#define UNSAT       0
+#define SAT         1
+#define ID         -1
+#define PIVOT      -2
+#define MAXDEP	   -3
+#define EXTRA       4		// ID + PIVOT + MAXDEP + terminating 0
+#define INFOBITS    2		// could be 1 for SAT, must be 2 for QBF
+#define DBIT        1
+#define ASSUMED     2
+#define MARK        3
+#define ERROR      -1
+#define ACTIVE      1
+
+#define FORWARD_SAT      10
+#define FORWARD_UNSAT    20
+#define BACKWARD_UNSAT   30
+#define SUCCESS          40
+#define FAILED           50
+#define FIXPOINT	 60
+#define NOWARNING	 70
+#define HARDWARNING	 80
+
+#define COMPRESS
+
+struct solver { FILE *inputFile, *proofFile, *lratFile, *traceFile, *activeFile;
+    int *DB, nVars, timeout, mask, delete, *falseStack, *falseA, *forced, binMode, optimize, binOutput,
+      *processed, *assigned, count, *used, *max, COREcount, RATmode, RATcount, nActive, *lratTable,
+      nLemmas, maxRAT, *RATset, *preRAT, maxDependencies, nDependencies, bar, backforce, reduce,
+      *dependencies, maxVar, maxSize, mode, verb, unitSize, prep, *current, nRemoved, warning,
+      delProof, *setMap, *setTruth;
+    char *coreStr, *lemmaStr;
+    struct timeval start_time;
+    long mem_used, time, nClauses, nStep, nOpt, nAlloc, *unitStack, *reason, lemmas, nResolve,
+         nReads, nWrites, lratSize, lratAlloc, *lratLookup, **wlist, *optproof, *formula, *proof;  };
+
+static inline void assign (struct solver* S, int lit) {
+  S->falseA[-lit] = 1; *(S->assigned++) = -lit; }
+
+int compare (const void *a, const void *b) {
+  return (*(int*)a - *(int*)b); }
+
+int abscompare (const void *a, const void *b) {
+  return (abs(*(int*)a) - abs(*(int*)b)); }
+
+static inline void printClause (int* clause) {
+  printf ("[%i] ", clause[ID]);
+  while (*clause) printf ("%i ", *clause++); printf ("0\n"); }
+
+static inline void addWatchPtr (struct solver* S, int lit, long watch) {
+  if (S->used[lit] + 1 == S->max[lit]) { S->max[lit] *= 1.5;
+    S->wlist[lit] = (long *) realloc (S->wlist[lit], sizeof (long) * S->max[lit]);
+//    if (S->max[lit] > 1000) printf("c watchlist %i increased to %i\n", lit, S->max[lit]);
+    if (S->wlist[lit] == NULL) { printf("c MEMOUT: reallocation failed for watch list of %i\n", lit); exit (0); } }
+  S->wlist[lit][ S->used[lit]++ ] = watch | S->mask;
+  S->wlist[lit][ S->used[lit]   ] = END; }
+
+static inline void addWatch (struct solver* S, int* clause, int index) {
+  addWatchPtr (S, clause[index], ((long) (((clause) - S->DB)) << 1)); }
+
+static inline void removeWatch (struct solver* S, int* clause, int index) {
+  int i, lit = clause[index];
+  if ((S->used[lit] > INIT) && (S->max[lit] > 2 * S->used[lit])) {
+    S->max[lit] = (3 * S->used[lit]) >> 1;
+    S->wlist[lit] = (long *) realloc (S->wlist[lit], sizeof (long) * S->max[lit]);
+    assert(S->wlist[lit] != NULL); }
+  long *watch = S->wlist[lit];
+  for (i = 0; i < S->used[lit]; i++) {
+    int* _clause = S->DB + (*(watch++) >> 1);
+    if (_clause == clause) {
+      watch[-1] = S->wlist[lit][ --S->used[lit] ];
+      S->wlist[lit][ S->used[lit] ] = END; return; } } }
+
+static inline void addUnit (struct solver* S, long index) {
+  S->unitStack[S->unitSize++] = index; }
+
+static inline void removeUnit (struct solver* S, int lit) {
+  int i, found = 0;
+  for (i = 0; i < S->unitSize; i++) {
+    if (found) S->unitStack[i - 1] = S->unitStack[i];
+    if (S->DB[ S->unitStack[i] ] == lit) found = 1; }
+  S->unitSize--; }
+
+static inline void unassignUnit (struct solver* S, int lit) {
+  if (S->verb)
+    printf ("c removing unit %i\n", lit);
+  while (S->falseA[-lit]) {
+    if (S->verb)
+      printf ("c removing unit %i (%i)\n", S->forced[-1], lit);
+    S->falseA[*(--S->forced)] = 0;
+    S->reason[abs(*S->forced)] = 0; }
+  S->processed = S->assigned = S->forced; }
+
+static inline void markWatch (struct solver* S, int* clause, int index, int offset) {
+  long* watch = S->wlist[ clause[ index ] ];
+  for (;;) {
+    int *_clause = (S->DB + (*(watch++) >> 1) + (long) offset);
+    if (_clause == clause) { watch[ID] |= ACTIVE; return; } } }
+
+static inline void addDependency (struct solver* S, int dep, int forced) {
+  if (1 || S->traceFile || S->lratFile) { // temporary for MAXDEP
+    if (S->nDependencies == S->maxDependencies) {
+      S->maxDependencies = (S->maxDependencies * 3) >> 1;
+//      printf ("c dependencies increased to %i\n", S->maxDependencies);
+      S->dependencies = realloc (S->dependencies, sizeof (int) * S->maxDependencies);
+      if (S->dependencies == NULL) { printf ("c MEMOUT: dependencies reallocation failed\n"); exit (0); } }
+//    printf("c adding dep %i\n", (dep << 1) + forced);
+    S->dependencies[S->nDependencies++] = (dep << 1) + forced; } }
+
+static inline void markClause (struct solver* S, int* clause, int index) {
+  S->nResolve++;
+  addDependency (S, clause[index - 1] >> 1, (S->assigned > S->forced));
+
+  if ((clause[index + ID] & ACTIVE) == 0) {
+    S->nActive++;
+    clause[index + ID] |= ACTIVE;
+    if ((S->mode == BACKWARD_UNSAT) && clause[index + 1]) {
+      S->optproof[S->nOpt++] = (((long) (clause - S->DB) + index) << INFOBITS) + 1; }
+    if (clause[1 + index] == 0) return;
+    markWatch (S, clause,     index, -index);
+    markWatch (S, clause, 1 + index, -index); }
+  while (*clause) S->falseA[*(clause++)] = MARK; }
+
+void analyze (struct solver* S, int* clause, int index) {     // Mark all clauses involved in conflict
+  markClause (S, clause, index);
+  while (S->assigned > S->falseStack) {
+    int lit = *(--S->assigned);
+    if (S->falseA[lit] == MARK) {
+      if (S->reason[abs (lit)]) {
+        markClause (S, S->DB + S->reason[abs (lit)], -1);
+        if (S->assigned >= S->forced)
+          S->reason[abs (lit)] = 0; } }
+    else if (S->falseA[lit] == ASSUMED && !S->RATmode && S->reduce && !S->lratFile) { // Remove unused literal
+      S->nRemoved++;
+      int *tmp = S->current;
+      while (*tmp != lit) tmp++;
+      while (*tmp) { tmp[0] = tmp[1]; tmp++; }
+      tmp[-1] = 0; }
+    if (S->assigned >= S->forced) S->reason[abs (lit)] = 0;
+    S->falseA[lit] = (S->assigned < S->forced); }
+
+  S->processed = S->assigned = S->forced; }
+
+void noAnalyze (struct solver* S) {
+  while (S->assigned > S->falseStack) {
+    int lit = *(--S->assigned);
+    if (S->assigned >= S->forced) S->reason[abs (lit)] = 0;
+    S->falseA[lit] = (S->assigned < S->forced); }
+
+  S->processed = S->assigned = S->forced; }
+
+int propagate (struct solver* S, int init, int mark) { // Performs unit propagation (init not used?)
+  int *start[2];
+  int check = 0, mode = !S->prep;
+  int i, lit, _lit = 0; long *watch, *_watch;
+  start[0] = start[1] = S->processed;
+  flip_check:;
+  check ^= 1;
+  while (start[check] < S->assigned) {                 // While unprocessed false literals
+    lit = *(start[check]++);                           // Get first unprocessed literal
+    if (lit == _lit) watch = _watch;
+    else watch = S->wlist[ lit ];                      // Obtain the first watch pointer
+    while (*watch != END) {                            // While there are watched clauses (watched by lit)
+     if ((*watch & mode) != check) {
+        watch++; continue; }
+     int *clause = S->DB + (*watch >> 1);	       // Get the clause from DB
+     if (S->falseA[ -clause[0] ] ||
+         S->falseA[ -clause[1] ]) {
+       watch++; continue; }
+     if (clause[0] == lit) clause[0] = clause[1];      // Ensure that the other watched literal is in front
+      for (i = 2; clause[i]; ++i)                      // Scan the non-watched literals
+        if (S->falseA[ clause[i] ] == 0) {             // When clause[j] is not false, it is either true or unset
+          clause[1] = clause[i]; clause[i] = lit;      // Swap literals
+          addWatchPtr (S, clause[1], *watch);          // Add the watch to the list of clause[1]
+          *watch = S->wlist[lit][ --S->used[lit] ];    // Remove pointer
+          S->wlist[lit][ S->used[lit] ] = END;
+          goto next_clause; }                          // Goto the next watched clause
+      clause[1] = lit; watch++;                        // Set lit at clause[1] and set next watch
+      if (!S->falseA[  clause[0] ]) {                  // If the other watched literal is falsified,
+        assign (S, clause[0]);                         // A unit clause is found, and the reason is set
+        S->reason[abs (clause[0])] = ((long) ((clause)-S->DB)) + 1;
+        if (!check) {
+          start[0]--; _lit = lit; _watch = watch;
+          goto flip_check; } }
+      else if (!mark) { noAnalyze (S); return UNSAT; }
+      else { analyze (S, clause, 0); return UNSAT; }   // Found a root level conflict -> UNSAT
+      next_clause: ; } }                               // Set position for next clause
+  if (check) goto flip_check;
+  S->processed = S->assigned;
+  return SAT; }	                                       // Finally, no conflict was found
+
+
+// Propagate top level units
+static inline int propagateUnits (struct solver* S, int init) {
+  int i;
+//  printf("c propagateUnits %i\n", S->unitSize);
+  while (S->forced > S->falseStack) {
+    S->falseA[*(--S->forced)] = 0;
+    S->reason[abs (*S->forced)] = 0; }
+  S->forced = S->assigned = S->processed = S->falseStack;
+  for (i = 0; i < S->unitSize; i++) {
+    int lit = S->DB[ S->unitStack[i] ];
+    S->reason[abs (lit)] = S->unitStack[i] + 1;
+    assign (S, lit); }
+
+  if (propagate (S, init, 1) == UNSAT) { return UNSAT; }
+  S->forced = S->processed;
+  return SAT; }
+
+// Put falsified literals at the end and returns the size under the current
+// assignment: negative size means satisfied, size = 0 means falsified
+int sortSize (struct solver *S, int *lemma) {
+  unsigned int size = 0, last = 0, sat = 1;
+  while (lemma[last]) {
+    int lit = lemma[last++];
+    if (S->falseA[lit] == 0) {
+      if (S->falseA[-lit]) sat = -1;
+      lemma[last-1] = lemma[ size ];
+      lemma[size++] = lit; } }
+  return sat * size; }
+
+// print the core clauses to coreFile in DIMACS format
+void printCore (struct solver *S) {
+  int i, j;
+  for (i = 0; i < S->nClauses; i++) {
+    int *clause = S->DB + (S->formula[i] >> INFOBITS);
+    if (clause[ID] & ACTIVE) S->COREcount++; }
+  printf ("c %i of %li clauses in core                            \n", S->COREcount, S->nClauses);
+
+  if (S->coreStr) {
+    FILE *coreFile = fopen (S->coreStr, "w");
+    fprintf (coreFile, "p cnf %i %i\n", S->nVars, S->COREcount);
+    for (i = 0; i < S->nClauses; i++) {
+      int *clause = S->DB + (S->formula[i] >> INFOBITS);
+      if (clause[ID] & ACTIVE) {
+        while (*clause) fprintf (coreFile, "%i ", *clause++);
+        fprintf (coreFile, "0\n"); } }
+    fclose (coreFile); } }
+
+void write_lit (struct solver *S, int lit) { // change to long?
+  unsigned int l = abs (lit) << 1;
+  if (lit < 0) l++;
+
+  do {
+    if (l <= 127) { fputc ((char)                 l, S->lratFile); }
+    else          { fputc ((char) (128 + (l & 127)), S->lratFile); }
+    S->nWrites++;
+    l = l >> 7; }
+  while (l); }
+
+void printLRATline (struct solver *S, int time) {
+  int *line = S->lratTable + S->lratLookup[time];
+  if (S->binOutput) {
+    fputc ('a', S->lratFile); S->nWrites++;
+    while (*line) write_lit (S, *line++);
+    write_lit (S, *line++);
+    while (*line) write_lit (S, *line++);
+    write_lit (S, *line++); }
+  else {
+    while (*line) fprintf (S->lratFile, "%i ", *line++);
+    fprintf (S->lratFile, "%i ", *line++);
+    while (*line) fprintf (S->lratFile, "%i ", *line++);
+    fprintf (S->lratFile, "%i\n", *line++); } }
+
+// print the core lemmas to lemmaFile in DRAT format
+void printProof (struct solver *S) {
+  int step;
+  printf ("c %i of %i lemmas in core using %lu resolution steps\n", S->nActive - S->COREcount + 1, S->nLemmas + 1, S->nResolve);
+  printf ("c %d RAT lemmas in core; %i redundant literals in core lemmas\n", S->RATcount, S->nRemoved);
+
+  // NB: not yet working with forward checking
+  if (S->mode == FORWARD_UNSAT) {
+    printf ("c optimized proofs are not supported for forward checking\n");
+    return; }
+
+  // replace S->proof by S->optproof
+  if (S->mode == BACKWARD_UNSAT) {
+    if (S->nOpt > S->nAlloc) {
+      S->nAlloc = S->nOpt;
+      S->proof = (long*) realloc (S->proof, sizeof (long) * S->nAlloc);
+      if (S->proof == NULL) { printf("c MEMOUT: reallocation of proof list failed\n"); exit (0); } }
+    S->nStep   = 0;
+    S->nLemmas = 0;
+    for (step = S->nOpt - 1; step >= 0; step--) {
+      long ad = S->optproof[step];
+      int *lemmas = S->DB + (ad >> INFOBITS);
+      if ((ad & 1) == 0) S->nLemmas++;
+//      if (lemmas[ID] & ACTIVE) lemmas[ID] ^= ACTIVE; // only useful for checking multiple times?
+      S->proof[S->nStep++] = S->optproof[step]; } }  // why not reuse ad?
+
+  if (S->lemmaStr) {
+    FILE *lemmaFile = fopen (S->lemmaStr, "w");
+    for (step = 0; step < S->nStep; step++) {
+      long ad = S->proof[step];
+      int *lemmas = S->DB + (ad >> INFOBITS);
+      if (!lemmas[1] && (ad & 1)) continue; // don't delete unit clauses
+      if (ad & 1) fprintf (lemmaFile, "d ");
+      int reslit = lemmas[PIVOT];
+      while (*lemmas) {
+        int lit = *lemmas++;
+        if (lit == reslit)
+        fprintf (lemmaFile, "%i ", lit); }
+      lemmas = S->DB + (ad >> INFOBITS);
+      while (*lemmas) {
+        int lit = *lemmas++;
+        if (lit != reslit)
+          fprintf (lemmaFile, "%i ", lit); }
+      fprintf (lemmaFile, "0\n"); }
+    fprintf (lemmaFile, "0\n");
+    fclose (lemmaFile); }
+
+  if (S->lratFile) {
+    int lastAdded = S->nClauses;
+    int flag = 0;
+    for (step = 0; step < S->nStep; step++) {
+      long ad = S->proof[step];
+      int *lemmas = S->DB + (ad >> INFOBITS);
+      if ((ad & 1) == 0) {
+        if (lastAdded == 0) {
+          if (S->binOutput) {
+            write_lit (S, 0); }
+          else {
+            fprintf (S->lratFile, "0\n"); } }
+        lastAdded = lemmas[ID] >> 1;
+        printLRATline (S, lastAdded); }
+      else if (lastAdded == S->nClauses) continue;
+      else if (!lemmas[1] && (ad & 1)) continue; // don't delete unit clauses
+      else if (ad & 1) {
+        if (lastAdded != 0) {
+          if (S->binOutput) {
+            fputc ('d', S->lratFile); S->nWrites++; }
+          else {
+            fprintf (S->lratFile, "%i d ", lastAdded); } }
+        lastAdded = 0;
+        if (S->binOutput) {
+          write_lit (S, lemmas[ID] >> 1); }
+        else {
+          fprintf (S->lratFile, "%i ", lemmas[ID] >> 1); } } }
+    if (lastAdded != S->nClauses) {
+      if (S->binOutput) {
+        write_lit (S, 0); }
+      else {
+        fprintf(S->lratFile, "0\n"); } }
+
+    printLRATline (S, S->count);
+
+    fclose (S->lratFile);
+    if (S->nWrites)
+      printf ("c wrote optimized proof in LRAT format of %li bytes\n", S->nWrites); } }
+
+void printNoCore (struct solver *S) {
+  if (S->lratFile) {
+    if (S->binOutput) {
+      fputc ('d', S->lratFile); S->nWrites++; }
+    else {
+      fprintf (S->lratFile, "%ld d ", S->nClauses); }
+    int i;
+    for (i = 0; i < S->nClauses; i++) {
+      int *clause = S->DB + (S->formula[i] >> INFOBITS);
+      if ((clause[ID] & ACTIVE) == 0) {
+        if (S->binOutput) {
+          write_lit (S, clause[ID] >> 1); }
+        else {
+          fprintf (S->lratFile, "%i ", clause[ID] >> 1); } } }
+    if (S->binOutput) {
+      write_lit (S, 0); }
+    else {
+      fprintf (S->lratFile, "0\n"); } } }
+
+// print the dependency graph to traceFile in TraceCheck+ format
+// this procedure adds the active clauses at the end of the trace
+void printTrace (struct solver *S) {
+  if (S->traceFile) { int i;
+    for (i = 0; i < S->nClauses; i++) {
+      int *clause = S->DB + (S->formula[i] >> INFOBITS);
+      if (clause[ID] & ACTIVE) {
+        fprintf (S->traceFile, "%i ", i + 1);
+        while (*clause) fprintf (S->traceFile, "%i ", *clause++);
+        fprintf (S->traceFile, "0 0\n"); } }
+    fclose (S->traceFile); } }
+
+void printActive (struct solver *S) {
+  int i, j;
+  if (S->activeFile) {
+    for (i = -S->maxVar; i <= S->maxVar; i++)
+      if (i != 0)
+        for (j = 0; j < S->used[i]; j++) {
+          int *clause = S->DB + (S->wlist[i][j] >> 1);
+          if (*clause == i) {
+            while (*clause)
+              fprintf (S->activeFile, "%i ", *clause++);
+            fprintf (S->activeFile, "0\n"); } } } }
+
+void postprocess (struct solver *S) {
+  printNoCore (S);   // print before proof optimization
+  printActive (S);
+  printCore   (S);
+  printTrace  (S);   // closes traceFile
+  printProof  (S); } // closes lratFile
+
+void lratAdd (struct solver *S, int elem) {
+  if (S->lratSize == S->lratAlloc) {
+    S->lratAlloc = S->lratAlloc * 3 >> 1;
+    S->lratTable = (int *) realloc (S->lratTable, sizeof (int) * S->lratAlloc); }
+  S->lratTable[S->lratSize++] = elem; }
+
+void printDependenciesFile (struct solver *S, int* clause, int RATflag, int mode) {
+  FILE *file = NULL;
+  if (mode == 0) file = S->traceFile;
+  if (mode == 1) file = S->lratFile;
+
+  if (file) {
+    int i, j, k;
+    int tmp = S->lratSize;
+
+    if (clause != NULL) {
+           S->lratLookup[clause[ID] >> 1] = S->lratSize; }
+    else { S->lratLookup[S->count] = S->lratSize;   }
+
+    if (clause != NULL) {
+      int size = 0;
+      int *sortClause;
+      sortClause = (int *) malloc (sizeof(int) * S->maxSize);
+      lratAdd (S, S->time >> 1); // NB: long to ing
+      int reslit = clause[PIVOT];
+      while (*clause) {
+        if (*clause == reslit)
+          lratAdd (S, reslit);
+        sortClause[size++] = *clause++; }
+      qsort (sortClause, size, sizeof (int), abscompare);
+      for (i = 0; i < size; i++) {
+        int lit = sortClause[i];
+        if (lit != reslit)
+          lratAdd (S, lit); } }
+    else { lratAdd (S, S->count); }
+    lratAdd (S, 0);
+
+    int isRUP = 1;
+    for (i = 0; i < S->nDependencies; i++)
+      if (S->dependencies[i] < 0) { isRUP = 0; break; }
+
+    if (isRUP) {
+      for (i = S->nDependencies - 1; i >= 0; i--)
+        lratAdd (S, S->dependencies[i] >> 1);
+      lratAdd (S, 0);
+      goto printLine; }
+
+    // first print the preRAT units in order of becoming unit
+    int size = 0;
+    for (i = 0; i < S->nDependencies; i++) {
+      if (S->dependencies[i] > 0) continue;
+      for (j = i - 1; j >= 0 && S->dependencies[j] > 0; j--) {
+        int flag = 0;
+        int cls  = S->dependencies[j];
+        if (cls & 1) continue;
+        for (k = 0; k < size; k++)
+          if (S->preRAT[k] == cls) flag = 1;
+        if (!flag) {
+          S->preRAT[size++] = cls;
+          lratAdd (S, cls >> 1); } } }
+
+    // print dependencies in order of becoming unit
+    for (i = S->nDependencies - 1; i >= 0; i--) {
+      int cls = S->dependencies[i];
+      if ((mode == 0) && (cls < 0)) continue;
+      if (mode == 0) {
+        int flag = 0;
+        for (j = 0; j < size; j++)
+          if (S->preRAT[j] == cls) flag = 1;
+        if (!flag) {
+          S->preRAT[size++] = cls;
+          lratAdd (S, cls >> 1); } }
+      if ((mode == 1) && (cls & 1))
+        lratAdd (S, cls >> 1); }
+      lratAdd (S, 0);
+
+    printLine:;
+    if (mode == 0) {
+      for (i = tmp; i < S->lratSize; i++)
+        fprintf (file, "%d ", S->lratTable[i]);
+      S->lratSize = tmp;
+      fprintf (file, "\n"); } } }
+
+void printDependencies (struct solver *S, int* clause, int RATflag) {
+  if (clause != NULL) {
+    int i;
+    clause[MAXDEP] = 0;
+    for (i = 0; i < S->nDependencies; i++) {
+//      printf ("%i ", S->dependencies[i]);
+      if (S->dependencies[i] > clause[MAXDEP])
+        clause[MAXDEP] = S->dependencies[i]; }
+//    printf("\n%i :", clause[MAXDEP]);
+//    printClause(clause);
+    assert (clause[MAXDEP] < clause[ID]);
+  }
+
+  printDependenciesFile (S, clause, RATflag, 0);
+  printDependenciesFile (S, clause, RATflag, 1); }
+
+int checkRAT (struct solver *S, int pivot, int mark) {
+  int i, j, nRAT = 0;
+
+  // Loop over all literals to calculate resolution candidates
+  for (i = -S->maxVar; i <= S->maxVar; i++) {
+    if (i == 0) continue;
+    // Loop over all watched clauses for literal
+    for (j = 0; j < S->used[i]; j++) {
+      int* watched = S->DB + (S->wlist[i][j] >> 1);
+      int id = watched[ID] >> 1;
+      int active = watched[ID] & ACTIVE;
+      if (*watched == i) { // If watched literal is in first position
+	while (*watched)
+          if (*watched++ == -pivot) {
+            if ((S->mode == BACKWARD_UNSAT) && !active) {
+//              printf ("c RAT check ignores unmarked clause : "); printClause (S->DB + (S->wlist[i][j] >> 1));
+              continue; }
+	    if (nRAT == S->maxRAT) {
+	      S->maxRAT = (S->maxRAT * 3) >> 1;
+	      S->RATset = realloc (S->RATset, sizeof (int) * S->maxRAT);
+              assert (S->RATset != NULL); }
+	    S->RATset[nRAT++] = S->wlist[i][j] >> 1;
+            break; } } } }
+
+  // S->prep = 1;
+  // Check all clauses in RATset for RUP
+  int flag = 1;
+  qsort (S->RATset, nRAT, sizeof (int), compare);
+  S->nDependencies = 0;
+  for (i = nRAT - 1; i >= 0; i--) {
+    int* RATcls = S->DB + S->RATset[i];
+    int id = RATcls[ID] >> 1;
+    int blocked = 0;
+    long int reason  = 0;
+    if (S->verb) {
+      printf ("c RAT clause: "); printClause (RATcls); }
+
+    while (*RATcls) {
+      int lit = *RATcls++;
+      if (lit != -pivot && S->falseA[-lit])
+        if (!blocked || reason > S->reason[abs (lit)])
+          blocked = lit, reason = S->reason[abs (lit)]; }
+
+    if (blocked && reason) {
+      analyze (S, S->DB + reason, -1);
+      S->reason[abs (blocked)] = 0; }
+
+    if (!blocked) {
+      RATcls = S->DB + S->RATset[i];
+      while (*RATcls) {
+        int lit = *RATcls++;
+        if (lit != -pivot && !S->falseA[lit]) {
+          assign (S, -lit); S->reason[abs (lit)] = 0; } }
+      if (propagate (S, 0, mark) == SAT) { flag  = 0; break; } }
+    addDependency (S, -id, 1); }
+
+  if (flag == 0) {
+    while (S->forced < S->assigned) {
+      S->falseA[*(--S->assigned)] = 0;
+      S->reason[abs (*S->assigned)] = 0; }
+    if (S->verb) printf ("c RAT check on pivot %i failed\n", pivot);
+    return FAILED; }
+
+  return SUCCESS; }
+
+int setUCP (struct solver *S, int *cnf, int *trail) {
+  int touched = 0, satisfied = 1;
+  int *clause = cnf;
+
+  while (*clause) {
+    int *literals = clause;
+    int unit = 0, sat = 0, und = 0;
+    int i;
+    while (*literals) {
+      int lit = *literals++;
+      if (S->setTruth[ lit ] == 1) { sat = 1; }
+      if (S->setTruth[ lit ] == 0) { und++; unit = lit; } }
+    clause = literals + 1;
+    if (!sat && und == 1) {
+      sat = 1;
+      touched = 1;
+      *trail++ = unit;
+      *trail   = 0;
+      if (S->verb) printf("c found unit %i\n", unit);
+      S->setTruth[ unit] =  1;
+      S->setTruth[-unit] = -1; }
+    satisfied &= sat;
+    if (!sat && !und) return FAILED; }
+
+  *trail = 0;
+  if (satisfied) return SUCCESS;
+  if ( touched ) return setUCP (S, cnf, trail);
+  return FIXPOINT; }
+
+/*
+int setDLL (struct solver *S, int *cnf, int *trail) {
+  int res = setUCP (S, cnf, trail);
+  if (res == SUCCESS) return SUCCESS;
+  if (res == FAILED ) return FAILED;
+  while (*trail) trail++;
+
+  int decision = 1;
+  while (S->setTruth[decision]) decision++;
+
+  *trail++ = decision;
+  *trail   = 0;
+  S->setTruth[ decision] =  1;
+  S->setTruth[-decision] = -1;
+
+  if (S->verb) printf("c branch on %i\n", decision);
+  if (setDLL (S, cnf, trail) == SUCCESS) return SUCCESS;
+
+  while (*trail) trail++;
+  while (*trail != decision) {
+    S->setTruth[ *trail] = 0;
+    S->setTruth[-*trail] = 0;
+    trail--; }
+
+  *trail++ = -decision;
+  *trail = 0;
+  S->setTruth[ decision] = -1;
+  S->setTruth[-decision] =  1;
+
+  if (S->verb) printf("c branch on %i\n", -decision);
+  return setDLL (S, cnf, trail); }
+
+int setRedundancyCheck (struct solver *S, int *clause, int size, int uni) {
+  int i, j, blocked, nSPR = 0;
+  long int reason;
+
+  int *trail = (int*) malloc (sizeof(int) * (size + 1));
+
+  if (S->verb) printf("c starting SPR check\n");
+
+  for (i = 1; i <= size; i++) {
+    trail            [i - 1]  =  0;
+    S->setMap[ clause[i - 1]] =  i;
+    S->setMap[-clause[i - 1]] = -i; }
+
+  // Loop over all literals to calculate resolution candidates
+  for (i = -S->maxVar; i <= S->maxVar; i++) {
+    if (i == 0) continue;
+    // Loop over all watched clauses for literal
+    for (j = 0; j < S->used[i]; j++) {
+      int* watchedClause = S->DB + (S->wlist[i][j] >> 1);
+      if (*watchedClause == i) { // If watched literal is in first position
+        int flag = 0;
+        blocked = 0;
+        reason = 0;
+        while (*watchedClause) {
+          int lit = *watchedClause++;
+          if (S->setMap[lit] < 0) flag = 1;
+          else if (!S->setMap[lit] && S->falseA[-lit]) {
+            if (blocked == 0 || reason > S->reason[ abs(lit) ])
+              blocked = lit, reason = S->reason[ abs(lit) ]; } }
+
+       if (blocked != 0 && reason != 0 && flag == 1) {
+         analyze (S, S->DB + reason, -1); S->reason[abs(blocked)] = 0; }
+
+       // If resolution candidate, add to list
+       if (blocked == 0 && flag == 1) {
+         if (nSPR == S->maxRAT) {
+           S->maxRAT = (S->maxRAT * 3) >> 1;
+           S->RATset = realloc(S->RATset, sizeof(int) * S->maxRAT); }
+         S->RATset[nSPR++] = S->wlist[i][j] >> 1; } } } }
+
+  // Check all candidates for RUP
+  int cnfSize = size + 2; // first clause + terminating zero
+  int filtered = 0;
+  for (i = 0; i < nSPR; i++) {
+    int inSet = 1;
+    int* candidate = S->DB + S->resolutionCandidates[i];
+    if (S->verb) {
+      printf("c candidate: "); printLiterals (candidate); }
+    while (*candidate) { int lit = *candidate++;
+      if (S->setMap[lit]) inSet++;
+      if (!S->setMap[lit] && !S->falseA[lit]) {
+        ASSIGN(-lit); S->reason[abs(lit)] = 0; } }
+    if (propagate (S, 0) == SAT) {
+      if (S->verb) printf(" FAILED\n");
+      cnfSize += inSet;
+      S->processed = S->forced;
+      while (S->forced < S->assigned) S->falseA[*(--S->assigned)] = 0;
+      S->resolutionCandidates[filtered++] = S->resolutionCandidates[i]; }
+    else {
+      if (S->verb) printf(" SUCCESS\n"); } }
+
+  int *cnf = (int*) malloc (sizeof(int) * cnfSize);
+  int *tmp = cnf;
+  for (i = 1; i <= size; i++) *tmp++ = i;
+  *tmp++ = 0;
+  numCandidates = filtered;
+  for (i = 0; i < numCandidates; i++) {
+    int* candidate = S->DB + S->resolutionCandidates[i];
+    while (*candidate) {
+      int lit = *candidate++;
+      if (S->setMap[lit]) *tmp++ = S->setMap[lit]; }
+    *tmp++ = 0; }
+  *tmp++ = 0;
+
+  if (S->verb) {
+    tmp = cnf;
+    printf("c printing CNF:\n");
+    while (*tmp) {
+      int *clause = tmp;
+      printf("c ");
+      while (*clause) printf("%i ", *clause++);
+      printf("\n");
+      tmp = clause + 1; } }
+
+  int res = setDLL (S, cnf, trail);
+  if (S->verb) {
+    if (res == SUCCESS) printf("c SUCCESS\n");
+    if (res == FAILED ) printf("c FAILED\n"); }
+
+  for (i = 1; i <= size; i++) {
+    S->setMap[ clause[i - 1]] = 0;
+    S->setMap[-clause[i - 1]] = 0;
+    S->setTruth[  i ]         = 0;
+    S->setTruth[ -i ]         = 0; }
+
+  free(trail);
+  free( cnf );
+  return res; }
+*/
+
+int redundancyCheck (struct solver *S, int *clause, int size, int mark) {
+  int i, indegree;
+  int falsePivot = S->falseA[clause[PIVOT]];
+  if (S->verb) { printf ("c checking lemma (%i, %i) ", size, clause[PIVOT]); printClause (clause); }
+
+  if (S->mode != FORWARD_UNSAT) {
+    if ((clause[ID] & ACTIVE) == 0) return SUCCESS; }  // redundant?
+//    clause[PIVOT] ^= ACTIVE; }
+
+  if (size < 0) {
+    S->DB[ S->reason[abs (*clause)] - 2] |= 1;
+    return SUCCESS; }
+
+  indegree = S->nResolve;
+
+  S->RATmode = 0;
+  S->nDependencies = 0;
+  for (i = 0; i < size; ++i) {
+    if (S->falseA[-clause[i]]) { // should only occur in forward mode
+      if (S->warning != NOWARNING) {
+        printf ("c WARNING: found a tautological clause in proof: "); printClause (clause); }
+      if (S->warning == HARDWARNING) exit (HARDWARNING);
+      while (S->forced < S->assigned) {
+        S->falseA[*(--S->assigned)] = 0;
+        S->reason[abs (*S->assigned)] = 0; }
+      return SUCCESS; }
+    S->falseA[clause[i]] = ASSUMED;
+    *(S->assigned++) = clause[i];
+    S->reason[abs (clause[i])] = 0; }
+
+  S->current = clause;
+  if (propagate (S, 0, mark) == UNSAT) {
+    indegree = S->nResolve - indegree;
+    if (indegree <= 2 && S->prep == 0) {
+      S->prep = 1; if (S->verb) printf ("c [%li] preprocessing checking mode on\n", S->time); }
+    if (indegree  > 2 && S->prep == 1) {
+      S->prep = 0; if (S->verb) printf ("c [%li] preprocessing checking mode off\n", S->time); }
+    if (S->verb) printf ("c lemma has RUP\n");
+    printDependencies (S, clause, 0);
+    return SUCCESS; }
+
+  // Failed RUP check.  Now test RAT.
+  // printf ("RUP check failed.  Starting RAT check.\n");
+  int reslit = clause[PIVOT];
+  if (S->verb)
+    printf ("c RUP checked failed; starting RAT check on pivot %d.\n", reslit);
+
+  if (falsePivot) return FAILED;
+
+  int* savedForced = S->forced;
+
+  S->RATmode = 1;
+  S->forced = S->assigned;
+
+  int failed = 0;
+  if (checkRAT (S, reslit, mark) == FAILED) {
+    failed = 1;
+    if (S->warning != NOWARNING) {
+      printf ("c WARNING: RAT check on proof pivot failed : "); printClause (clause); }
+    if (S->warning == HARDWARNING) exit (HARDWARNING);
+    for (i = 0; i < size; i++) {
+      if (clause[i] == reslit) continue;
+      if (checkRAT (S, clause[i], mark) == SUCCESS) {
+        clause[PIVOT] = clause[i];
+        failed = 0; break; } } }
+
+  if (failed == 0)
+    printDependencies (S, clause, 1);
+
+  S->processed = S->forced = savedForced;
+  while (S->forced < S->assigned) {
+    S->falseA[*(--S->assigned)] = 0;
+    S->reason[abs (*S->assigned)] = 0; }
+
+  if (failed) {
+    printf ("c RAT check failed on all possible pivots\n");
+    return FAILED; }
+
+
+  if (mark) S->RATcount++;
+  if (S->verb) printf ("c lemma has RAT on %i\n", clause[PIVOT]);
+  return SUCCESS; }
+
+int init (struct solver *S) {
+  S->forced     = S->falseStack; // Points inside *falseStack at first decision (unforced literal)
+  S->processed  = S->falseStack; // Points inside *falseStack at first unprocessed literal
+  S->assigned   = S->falseStack; // Points inside *falseStack at last unprocessed literal
+
+  // initialize watch pointers on the original clauses
+  S->RATmode    = 0;
+  S->nRemoved   = 0;
+  S->nOpt       = 0;
+  S->nResolve   = 0;
+  S->RATcount   = 0;
+  S->nActive    = 0;
+  S->COREcount  = 0;
+  S->unitSize   = 0;
+
+  int i;
+  for (i = 1; i <= S->maxVar; ++i) {
+    S->reason    [i]                   = 0;
+    S->falseStack[i]                   = 0;
+    S->falseA[i]    = S->falseA[-i]    = 0;
+    S->used  [i]    = S->used  [-i]    = 0;
+    S->wlist [i][0] = S->wlist [-i][0] = END; }
+
+  for (i = 0; i < S->nClauses; i++) {
+    int *clause = S->DB + (S->formula[i] >> INFOBITS);
+    if (clause[ID] & ACTIVE) clause[ID] ^= ACTIVE;
+    if (clause[0] == 0) {
+      printf ("c formula contains empty clause\n");
+      if (S->coreStr) {
+        FILE *coreFile = fopen (S->coreStr, "w");
+        fprintf (coreFile, "p cnf 0 1\n 0\n");
+        fclose (coreFile); }
+      if (S->lemmaStr) {
+        FILE *lemmaFile = fopen (S->lemmaStr, "w");
+        fprintf (lemmaFile, "0\n");
+        fclose (lemmaFile); }
+      return UNSAT; }
+    if (clause[1]) { addWatch (S, clause, 0); addWatch (S, clause, 1); }
+    else if (S->falseA[clause[0]]) {
+      printf ("c found complementary unit clauses\n");
+      if (S->coreStr) {
+        FILE *coreFile = fopen (S->coreStr, "w");
+        fprintf (coreFile, "p cnf %i 2\n%i 0\n%i 0\n", abs (clause[0]), clause[0], -clause[0]);
+        fclose (coreFile); }
+      if (S->lemmaStr) {
+        FILE *lemmaFile = fopen (S->lemmaStr, "w");
+        fprintf (lemmaFile, "0\n");
+        fclose (lemmaFile); }
+      if (S->lratFile) {
+        int j;
+        for (j = 0; j < i; j++) {
+          int *_clause = S->DB + (S->formula[j] >> INFOBITS);
+          if ((_clause[0] == -clause[0]) && !_clause[1]) break; }
+        fprintf (S->lratFile, "%li 0 %i %i 0\n", S->nClauses + 1, j + 1, i + 1); }
+      return UNSAT; }
+    else if (!S->falseA[ -clause[0] ]) {
+      addUnit (S, (long) (clause - S->DB));
+      assign (S, clause[0]); } }
+
+  S->nDependencies = 0;
+  S->time = S->count; // Alternative time init
+  if (propagateUnits (S, 1) == UNSAT) {
+    printf ("c UNSAT via unit propagation on the input instance\n");
+    printDependencies (S, NULL, 0);
+    postprocess (S); return UNSAT; }
+  return SAT; }
+
+int verify (struct solver *S, int begin, int end) {
+  int top_flag = 1;
+  if (init (S) == UNSAT) return UNSAT;
+
+  if (S->mode == FORWARD_UNSAT) {
+    if (begin == end)
+      printf ("c start forward verification\n"); }
+
+  int step;
+  int adds = 0;
+  int active = S->nClauses;
+  for (step = 0; step < S->nStep; step++) {
+    if (step >= begin && step < end) continue;
+    long ad = S->proof[step]; long d = ad & 1;
+    int *lemmas = S->DB + (ad >> INFOBITS);
+
+    S->time = lemmas[ID];
+    if (d) { active--; }
+    else   { active++; adds++; }
+    if (S->mode == FORWARD_SAT && S->verb) printf ("c %i active clauses\n", active);
+
+    if (!lemmas[1]) { // found a unit
+      int lit = lemmas[0];
+      if (S->verb)
+        printf ("c found unit in proof %i [%li]\n", lit, S->time);
+      if (d) {
+        if (S->mode == FORWARD_SAT) {
+          removeUnit (S, lit); propagateUnits (S, 0); }
+        else { // no need to remove units while checking UNSAT
+          if (S->verb) { printf("c removing proof step: d "); printClause(lemmas); }
+          S->proof[step] = 0; continue; } }
+      else {
+        if (S->mode == BACKWARD_UNSAT && S->falseA[-lit]) { S->proof[step] = 0; continue; }
+        else { addUnit (S, (long) (lemmas - S->DB)); } } }
+
+    if (d && lemmas[1]) { // if delete and not unit
+      if ((S->reason[abs (lemmas[0])] - 1) == (lemmas - S->DB)) { // what is this check?
+        if (S->mode != FORWARD_SAT) { // ignore pseudo unit clause deletion
+          if (S->verb) { printf ("c ignoring deletion intruction %li: ", (lemmas - S->DB)); printClause (lemmas); }
+//        if (S->mode == BACKWARD_UNSAT) { // ignore pseudo unit clause deletion
+          S->proof[step] = 0; }
+        else { // if (S->mode == FORWARD_SAT) { // also for FORWARD_UNSAT?
+          removeWatch (S, lemmas, 0), removeWatch (S, lemmas, 1);
+          propagateUnits (S, 0); } }
+      else {
+        removeWatch (S, lemmas, 0), removeWatch (S, lemmas, 1); }
+      if (S->mode == FORWARD_UNSAT ) continue;   // Ignore deletion of top-level units
+      if (S->mode == BACKWARD_UNSAT) continue; }
+
+    int size = sortSize (S, lemmas); // after removal of watches
+
+    if (d && S->mode == FORWARD_SAT) {
+      if (size == -1) propagateUnits (S, 0);  // necessary?
+      if (redundancyCheck (S, lemmas, size, 1) == FAILED)  {
+        printf ("c failed at proof line %i (modulo deletion errors)\n", step + 1);
+        return SAT; }
+      continue; }
+
+    if (d == 0 && S->mode == FORWARD_UNSAT) {
+      if (step > end) {
+        if (size < 0) continue; // Fix of bus error: 10
+        if (redundancyCheck (S, lemmas, size, 1) == FAILED) {
+          printf ("c failed at proof line %i (modulo deletion errors)\n", step + 1);
+          return SAT; }
+
+        size = sortSize (S, lemmas);
+        S->nDependencies = 0; } }
+
+    if (lemmas[1])
+      addWatch (S, lemmas, 0), addWatch (S, lemmas, 1);
+
+    if (size == 0) { printf ("c conflict claimed, but not detected\n"); return SAT; }  // change to FAILED?
+    if (size == 1) {
+      if (S->verb) printf ("c found unit %i\n", lemmas[0]);
+      assign (S, lemmas[0]); S->reason[abs (lemmas[0])] = ((long) ((lemmas)-S->DB)) + 1;
+      if (propagate (S, 1, 1) == UNSAT) goto start_verification;
+      S->forced = S->processed; } }
+
+  if (S->mode == FORWARD_SAT && active == 0) {
+    postprocess (S); return UNSAT; }
+
+  if (S->mode == FORWARD_UNSAT) {
+    if (begin == end) {
+      postprocess (S);
+      printf ("c ERROR: all lemmas verified, but no conflict\n"); }
+    return SAT; }
+
+  if (S->mode == BACKWARD_UNSAT) {
+    if (S->backforce) {
+      int s;
+      for (s = 0; s < step; s++) {
+        long ad = S->proof[s];
+        int *clause = S->DB + (ad >> INFOBITS);
+        if (sortSize(S, clause) >= 0) {
+          if ( (ad & 1) && (clause[ID] & 1)) clause[ID] ^= ACTIVE;
+          if (!(ad & 1))                     clause[ID] |= ACTIVE; } } }
+    if (!S->backforce) {
+      printf ("c ERROR: no conflict\n");
+      return SAT; } }
+
+  start_verification:;
+  if (S->mode == FORWARD_UNSAT) {
+    printDependencies (S, NULL, 0);
+    postprocess (S); return UNSAT; }
+
+  if (!S->backforce)
+    printDependencies (S, NULL, 0);
+
+  if (S->mode == FORWARD_SAT) {
+    printf ("c ERROR: found empty clause during SAT check\n"); exit (0); }
+  printf ("c detected empty clause; start verification via backward checking\n");
+
+  S->forced = S->processed;
+  assert (S->mode == BACKWARD_UNSAT); // only reachable in BACKWARD_UNSAT mode
+
+  S->nOpt = 0;
+
+  int checked = 0, skipped = 0;
+
+  double max = (double) adds;
+
+  struct timeval backward_time;
+  gettimeofday (&backward_time, NULL);
+  for (; step >= 0; step--) {
+    struct timeval current_time;
+    gettimeofday (&current_time, NULL);
+    int seconds = (int) (current_time.tv_sec - S->start_time.tv_sec);
+    if ((seconds > S->timeout) && (S->optimize == 0)) printf ("s TIMEOUT\n"), exit (0);
+
+    if (S->bar)
+      if ((adds % 1000) == 0) {
+        int f;
+        long runtime = (current_time.tv_sec  - backward_time.tv_sec ) * 1000000 +
+                       (current_time.tv_usec - backward_time.tv_usec);
+        double time = (double) (runtime / 1000000.0);
+        double fraction = (adds * 1.0) / max;
+        printf("c %.2f%% [", 100.0 * (1.0 - fraction));
+        for (f = 1; f <= 20; f++) {
+          if ((1.0 - fraction) * 20.0 < 1.0 * f) printf(" ");
+          else printf("="); }
+        printf("] time remaining: %.2f seconds ", time / (1.0 - fraction) - time);
+        if (step == 0) printf("\n");
+        fflush (stdout); }
+
+    long ad = S->proof[step]; long d = ad & 1;
+    int *clause = S->DB + (ad >> INFOBITS);
+
+
+    if (ad == 0) continue; // Skip lemma that has been removed from proof
+    if ( d == 0) {
+      adds--;
+      if (clause[1]) {
+        removeWatch (S, clause, 0), removeWatch (S, clause, 1);
+        if (S->reason[abs (clause[0])] == (clause + 1 - S->DB)) {  // use this check also for units?
+          unassignUnit (S, clause[0]); } }
+      else unassignUnit (S, clause[0]); }
+
+    int size = sortSize (S, clause);
+
+    if (d) {
+      if (S->verb) { printf ("c adding clause (%i) ", size); printClause (clause); }
+      addWatch (S, clause, 0), addWatch (S, clause, 1); continue; }
+
+    S->time = clause[ID];
+    if ((S->time & ACTIVE) == 0) {
+      skipped++;
+//      if ((skipped % 100) == 0) printf("c skipped %i, checked %i\n", skipped, checked);
+      continue; } // If not marked, continue
+
+    assert (size >= 1);
+    int *_clause = clause + size;
+    while (*_clause++) { S->nRemoved++; }
+    clause[size] = 0;
+
+    if (S->verb) {
+      printf ("c validating clause (%i, %i):  ", clause[PIVOT], size); printClause (clause); }
+/*
+    int i;
+    if (size > 1 && (top_flag == 1)) {
+      int last = clause[size - 1];
+      int pivot = clause[PIVOT];
+      for (i = 0; i < size; i++) {
+        int tmp = clause[i];
+        clause[i] = last;
+        clause[size - 1] = 0;
+        if (tmp == pivot) clause[PIVOT] = clause[0];
+        if (redundancyCheck (S, clause, size - 1, 0) != FAILED) {
+          top_flag = 0;
+          size = size - 1; break; }
+        else {
+          clause[i] = tmp;
+          clause[size - 1] = last; }
+        clause[PIVOT] = pivot; } }
+*/
+    if (redundancyCheck (S, clause, size, 1) == FAILED) {
+      printf ("c failed at proof line %i (modulo deletion errors)\n", step + 1);
+      return SAT; }
+    checked++;
+    S->optproof[S->nOpt++] = ad; }
+
+  postprocess (S);
+  return UNSAT; }
+
+long matchClause (struct solver* S, long *clauselist, int listsize, int* input, int size) {
+  int i, j;
+  for (i = 0; i < listsize; ++i) {
+    int *clause = S->DB + clauselist[i];
+    for (j = 0; j <= size; j++)
+      if (clause[j] != input[j]) goto match_next;
+
+    long result = clauselist[i];
+    clauselist[i] = clauselist[--listsize];
+    return result;
+    match_next:; }
+  return 0; }
+
+unsigned int getHash (int* input) {
+  unsigned int sum = 0, prod = 1, xor = 0;
+  while (*input) {
+    prod *= *input; sum += *input; xor ^= *input; input++; }
+  return (1023 * sum + prod ^ (31 * xor)) % BIGINIT; }
+
+int read_lit (struct solver *S, int *lit) {
+  int l = 0, lc, shift = 0;
+  do {
+    lc = getc_unlocked (S->proofFile);
+    S->nReads++;
+    if ((shift == 0) && (lc == EOF)) return EOF;
+    l |= (lc & 127) << shift;
+    shift += 7; }
+  while (lc > 127);
+  if (l % 2) *lit = (l >> 1) * -1;
+  else       *lit = (l >> 1);
+  return 1; }
+
+void deactivate (struct solver *S) {
+  S->nActive = 0;
+  int step;
+  for (step = 0; step < S->nStep; step++) {
+    if ((S->proof[step] & 1) == 0) {
+      int *clause = S->DB + (S->proof[step] >> INFOBITS);
+      if (clause[ID] & ACTIVE) clause[ID] ^= ACTIVE; } }
+}
+
+void shuffleProof (struct solver *S, int iteration) {
+  int i, step, _step;
+
+  double base = 100;
+  for (i = 1; i < iteration; i++)
+    base *= 1.1;
+
+  // randomly remove clause deletion steps
+  for (_step = 0, step = 0; step < S->nStep; step++) {
+    if (S->proof[step] & 1) {
+      int length = 0;
+      int *clause = S->DB + (S->proof[step] >> INFOBITS);
+      while (*clause) { length++; clause++; }
+      if ((rand() % 1000) < (base * iteration / length)) continue; }
+    S->proof[_step++] = S->proof[step]; }
+  S->nStep = _step;
+
+  for (step = S->nStep - 1; step > 0; step--) {
+    long a = S->proof[step  ];
+    if (a & DBIT) continue;
+    long b = S->proof[step-1];
+    if (b & DBIT) {
+      S->proof[step  ] = b;
+      S->proof[step-1] = a; }
+    else {
+      int *c = S->DB + (a >> INFOBITS);
+      int *d = S->DB + (b >> INFOBITS);
+      int coinflip = 0;
+//      int coinflip = rand () / (RAND_MAX >> 1);
+      if (c[MAXDEP] < d[MAXDEP] || (coinflip && (c[MAXDEP] < d[ID]))) {
+        int tmp = d[ID];
+        d[ID] = c[ID];
+        c[ID] = tmp;
+        S->proof[step  ] = b;
+        S->proof[step-1] = a; } } }
+
+  for (step = 0; step < S->nStep; step++) {
+    long ad = S->proof[step];
+    if (ad & 1) continue;
+    int *clause = S->DB + (ad >> INFOBITS);
+    int i, length = 0;
+    while (*clause) { length++; clause++; }
+    clause = S->DB + (ad >> INFOBITS);
+    for (i = 0; i < length - 1; i++) {
+      int j = i + rand() / (RAND_MAX / (length - i) + 1);
+      int t = clause[i]; clause[i] = clause[j]; clause[j] = t; } } }
+
+int parse (struct solver* S) {
+  int tmp, active = 0, retvalue = SAT;
+  int del = 0, fileLine = 0;
+  int *buffer, bufferAlloc;
+
+  S->nVars    = 0;
+  S->nClauses = 0;
+  do { tmp = fscanf (S->inputFile, " cnf %i %li \n", &S->nVars, &S->nClauses); // Read the first line
+    if (tmp > 0 && tmp != EOF) break; tmp = fscanf (S->inputFile, "%*s\n"); }  // In case a commment line was found
+  while (tmp != 2 && tmp != EOF);                                              // Skip it and read next line
+  int nZeros = S->nClauses;
+
+  if (!S->nVars && !S->nClauses) {
+    printf ("c ERROR: did not find p cnf line in input file\n"); exit (0); }
+
+  printf ("c parsing input formula with %i variables and %li clauses\n", S->nVars, S->nClauses);
+
+  bufferAlloc = INIT;
+  buffer = (int*) malloc (sizeof (int) * bufferAlloc);
+
+  S->count    = 1;
+  S->nStep    = 0;
+  S->mem_used = 0;                  // The number of integers allocated in the DB
+
+  long size;
+  long DBsize = S->mem_used + BIGINIT;
+  S->DB = (int*) malloc (DBsize * sizeof (int));
+  if (S->DB == NULL) { free (buffer); return ERROR; }
+
+  S->maxVar  = 0;
+  S->maxSize = 0;
+  S->nLemmas = 0;
+  S->nAlloc  = BIGINIT;
+  S->formula = (long *) malloc (sizeof (long) * S->nClauses);
+  S->proof   = (long *) malloc (sizeof (long) * S->nAlloc);
+  long **hashTable = (long**) malloc (sizeof (long*) * BIGINIT);
+  int   *hashUsed  = (int * ) malloc (sizeof (int  ) * BIGINIT);
+  int   *hashMax   = (int * ) malloc (sizeof (int  ) * BIGINIT);
+
+  int i;
+  for (i = 0; i < BIGINIT; i++) {
+    hashUsed [i] = 0;
+    hashMax  [i] = INIT;
+    hashTable[i] = (long*) malloc (sizeof (long) * hashMax[i]); }
+
+  int fileSwitchFlag = 0;
+  size = 0;
+  while (1) {
+    int lit = 0; tmp = 0;
+    fileSwitchFlag = nZeros <= 0;
+
+    if (size == 0) {
+      if (fileSwitchFlag) { // read for proof
+        if (S->binMode) {
+          int res = getc_unlocked (S->proofFile);
+          if      (res == EOF) break;
+          else if (res ==  97) del = 0;
+          else if (res == 100) del = 1;
+          else { printf ("c ERROR: wrong binary prefix\n"); exit (0); }
+          S->nReads++; }
+        else {
+          tmp = fscanf (S->proofFile, " d  %i ", &lit);
+          if (tmp == EOF) break;
+          del = tmp > 0; } } }
+
+    if (!lit) {
+      if (!fileSwitchFlag) tmp = fscanf (S->inputFile, " %i ", &lit);  // Read a literal.
+      else {
+        if (S->binMode) {
+          tmp = read_lit (S, &lit); }
+        else {
+          tmp = fscanf (S->proofFile, " %i ", &lit); } }
+      if (tmp == EOF && !fileSwitchFlag) {
+        if (S->warning != NOWARNING) {
+          printf ("c WARNING: early EOF of the input formula\n");
+          printf ("c WARNING: %i clauses less than expected\n", nZeros); }
+        if (S->warning == HARDWARNING) exit (HARDWARNING);
+        fileLine = 0;
+        fileSwitchFlag = 1; } }
+
+    if (tmp == 0) {
+      char ignore[1024];
+      if (!fileSwitchFlag) { if (fgets (ignore, sizeof (ignore), S->inputFile) == NULL) printf ("c\n"); }
+      else if (fgets (ignore, sizeof (ignore), S->proofFile) == NULL) printf ("c\n");
+      for (i = 0; i < 1024; i++) { if (ignore[i] == '\n') break; }
+      if (i == 1024) {
+        printf ("c ERROR: comment longer than 1024 characters: %s\n", ignore);
+        exit (HARDWARNING); }
+      if (S->verb) printf ("c WARNING: parsing mismatch assuming a comment\n");
+      continue; }
+
+    if (abs (lit) > S->maxVar) S->maxVar = abs (lit);
+    if (tmp == EOF && fileSwitchFlag) break;
+    if (abs (lit) > S->nVars && !fileSwitchFlag) {
+      printf ("c illegal literal %i due to max var %i\n", lit, S->nVars); exit (0); }
+    if (!lit) {
+      fileLine++;
+      if (size > S->maxSize) S->maxSize = size;
+      int pivot = buffer[0];
+      buffer[size] = 0;
+      qsort (buffer, size, sizeof (int), compare);
+      int j = 0;
+      for (i = 0; i < size; ++i) {
+        if (buffer[i] == buffer[i+1]) {
+          if (S->warning != NOWARNING) {
+            printf ("c WARNING: detected and deleted duplicate literal %i at position %i of line %i\n", buffer[i+1], i+1, fileLine); }
+          if (S->warning == HARDWARNING) exit (HARDWARNING); }
+        else { buffer[j++] = buffer[i]; } }
+      buffer[j] = 0; size = j;
+
+      if (size == 0 && !fileSwitchFlag) retvalue = UNSAT;
+      if (del && S->mode == BACKWARD_UNSAT && size <= 1)  {
+        if (S->warning != NOWARNING) {
+          printf ("c WARNING: backward mode ignores deletion of (pseudo) unit clause ");
+          printClause (buffer); }
+        if (S->warning == HARDWARNING) exit (HARDWARNING);
+        del = 0; size = 0; continue; }
+      int rem = buffer[0];
+      buffer[size] = 0;
+      unsigned int hash = getHash (buffer);
+      if (del) {
+        if (S->delete) {
+          long match = 0;
+            match = matchClause (S, hashTable[hash], hashUsed[hash], buffer, size);
+            if (match == 0) {
+              if (S->warning != NOWARNING) {
+                printf ("c WARNING: deleted clause on line %i does not occur: ", fileLine); printClause (buffer); }
+              if (S->warning == HARDWARNING) exit (HARDWARNING);
+              goto end_delete; }
+            if (S->mode == FORWARD_SAT) S->DB[ match - 2 ] = rem;
+            hashUsed[hash]--;
+            active--;
+            if (S->nStep == S->nAlloc) { S->nAlloc = (S->nAlloc * 3) >> 1;
+              S->proof = (long*) realloc (S->proof, sizeof (long) * S->nAlloc);
+//              printf ("c proof allocation increased to %li\n", S->nAlloc);
+              if (S->proof == NULL) { printf("c MEMOUT: reallocation of proof list failed\n"); exit (0); } }
+            S->proof[S->nStep++] = (match << INFOBITS) + 1; }
+        end_delete:;
+        if (del) { del = 0; size = 0; continue; } }
+
+      if (S->mem_used + size + EXTRA > DBsize) { DBsize = (DBsize * 3) >> 1;
+	S->DB = (int *) realloc (S->DB, DBsize * sizeof (int));
+//        printf("c database increased to %li\n", DBsize);
+        if (S->DB == NULL) { printf("c MEMOUT: reallocation of clause database failed\n"); exit (0); } }
+      int *clause = &S->DB[S->mem_used + EXTRA - 1];
+      if (size != 0) clause[PIVOT] = pivot;
+      clause[ID] = 2 * S->count; S->count++;
+      if (S->mode == FORWARD_SAT) if (nZeros > 0) clause[ID] |= ACTIVE;
+
+      for (i = 0; i < size; ++i) { clause[ i ] = buffer[ i ]; } clause[ i ] = 0;
+      S->mem_used += size + EXTRA;
+
+      hash = getHash (clause);
+      if (hashUsed[hash] == hashMax[hash]) { hashMax[hash] = (hashMax[hash] * 3) >> 1;
+        hashTable[hash] = (long *) realloc (hashTable[hash], sizeof (long*) * hashMax[hash]);
+        if (hashTable[hash] == NULL) { printf("c MEMOUT reallocation of hash table %i failed\n", hash); exit (0); } }
+      hashTable[ hash ][ hashUsed[hash]++ ] = (long) (clause - S->DB);
+
+      active++;
+      if (nZeros > 0) { // if still parsing the formula
+        S->formula[S->nClauses - nZeros] = (((long) (clause - S->DB)) << INFOBITS); }
+      else {
+        if (S->nStep == S->nAlloc) { S->nAlloc = (S->nAlloc * 3) >> 1;
+          S->proof = (long*) realloc (S->proof, sizeof (long) * S->nAlloc);
+//        printf ("c proof allocation increased to %li\n", S->nAlloc);
+        if (S->proof == NULL) { printf("c MEMOUT: reallocation of proof list failed\n"); exit (0); } }
+        S->proof[S->nStep++] = (((long) (clause - S->DB)) << INFOBITS); }
+
+      if (nZeros <= 0) S->nLemmas++;
+
+      if (!nZeros) S->lemmas   = (long) (clause - S->DB); // S->lemmas is no longer pointer
+      size = 0; del = 0; --nZeros; }                      // Reset buffer
+   else {
+     buffer[size++] = lit;                                // Add literal to buffer
+     if (size == bufferAlloc) { bufferAlloc = (bufferAlloc * 3) >> 1;
+       buffer = (int*) realloc (buffer, sizeof (int) * bufferAlloc); } } }
+
+  if (S->mode == FORWARD_SAT && active) {
+    if (S->warning != NOWARNING)
+      printf ("c WARNING: %i clauses active if proof succeeds\n", active);
+    if (S->warning == HARDWARNING) exit (HARDWARNING);
+    for (i = 0; i < BIGINIT; i++) {
+      int j;
+      for (j = 0; j < hashUsed[i]; j++) {
+        printf ("c ");
+        int *clause = S->DB + hashTable [i][j];
+        printClause (clause);
+        if (S->nStep == S->nAlloc) { S->nAlloc = (S->nAlloc * 3) >> 1;
+          S->proof = (long*) realloc (S->proof, sizeof (long) * S->nAlloc);
+//          printf ("c proof allocation increased to %li\n", S->nAlloc);
+          if (S->proof == NULL) { printf("c MEMOUT: reallocation of proof list failed\n"); exit (0); } }
+        S->proof[S->nStep++] = (((int) (clause - S->DB)) << INFOBITS) + 1; } } }
+
+  S->DB = (int *) realloc (S->DB, S->mem_used * sizeof (int));
+
+  for (i = 0; i < BIGINIT; i++) free (hashTable[i]);
+  free (hashTable);
+  free (hashUsed);
+  free (hashMax);
+  free (buffer);
+
+  printf ("c finished parsing");
+  if (S->nReads) printf (", read %li bytes from proof file", S->nReads);
+  printf ("\n");
+
+  int n = S->maxVar;
+  S->falseStack = (int  *) malloc ((    n + 1) * sizeof (int )); // Stack of falsified literals -- this pointer is never changed
+  S->reason     = (long *) malloc ((    n + 1) * sizeof (long)); // Array of clauses
+  S->used       = (int  *) malloc ((2 * n + 1) * sizeof (int )); S->used     += n; // Labels for variables, non-zero means false
+  S->max        = (int  *) malloc ((2 * n + 1) * sizeof (int )); S->max      += n; // Labels for variables, non-zero means false
+  S->falseA     = (int  *) malloc ((2 * n + 1) * sizeof (int )); S->falseA   += n; // Labels for variables, non-zero means false
+  S->setMap     = (int  *) malloc ((2 * n + 1) * sizeof (int )); S->setMap   += n; // Labels for variables, non-zero means false
+  S->setTruth   = (int  *) malloc ((2 * n + 1) * sizeof (int )); S->setTruth += n; // Labels for variables, non-zero means false
+
+  S->optproof   = (long *) malloc (sizeof(long) * (2 * S->nLemmas + S->nClauses));
+
+  S->maxRAT = INIT;
+  S->RATset = (int*) malloc (sizeof (int) * S->maxRAT);
+  for (i = 0; i < S->maxRAT; i++) S->RATset[i] = 0; // is this required?
+
+  S->preRAT = (int*) malloc (sizeof (int) * n);
+
+  S->lratAlloc  = INIT;
+  S->lratSize   = 0;
+  S->lratTable  = (int  *) malloc (sizeof(int ) * S->lratAlloc);
+  S->lratLookup = (long *) malloc (sizeof(long) * (S->count + 1));
+
+  S->maxDependencies = INIT;
+  S->dependencies = (int*) malloc (sizeof (int) * S->maxDependencies);
+  for (i = 0; i < S->maxDependencies; i++) S->dependencies[i] = 0;  // is this required?
+
+  S->wlist = (long**) malloc (sizeof (long*) * (2*n+1)); S->wlist += n;
+
+  for (i = 1; i <= n; ++i) { S->max     [ i] = S->max     [-i] = INIT;
+                             S->setMap  [ i] = S->setMap  [-i] =    0;
+                             S->setTruth[ i] = S->setTruth[-i] =    0;
+                             S->wlist   [ i] = (long*) malloc (sizeof (long) * S->max[ i]);
+                             S->wlist   [-i] = (long*) malloc (sizeof (long) * S->max[-i]); }
+
+  S->unitStack = (long *) malloc (sizeof (long) * n);
+
+  return retvalue; }
+
+void freeMemory (struct solver *S) {
+  int i;
+//  printf("c database size %li; ", S->mem_used);
+//  int sum = 0;
+//  for (i = 1; i <= S->maxVar; i++)
+//    sum += S->max[i] + S->max[-i];
+//  printf(" watch pointers size %i.\n", sum);
+
+  free (S->DB);
+  free (S->falseStack);
+  free (S->reason);
+  free (S->proof);
+  free (S->formula);
+  for (i = 1; i <= S->maxVar; ++i) { free (S->wlist[i]); free (S->wlist[-i]); }
+  free (S->used   - S->maxVar);
+  free (S->max    - S->maxVar);
+  free (S->falseA - S->maxVar);
+  free (S->wlist  - S->maxVar);
+  free (S->RATset);
+  free (S->dependencies);
+  return; }
+
+int onlyDelete (struct solver* S, int begin, int end) {
+  int step;
+  for (step = begin; step < end; step++)
+    if ((S->proof[step] & 1) == 0) return 0;
+  return 1; }
+
+void printHelp ( ) {
+  printf ("usage: drat-trim [INPUT] [<PROOF>] [<option> ...]\n\n");
+  printf ("where <option> is one of the following\n\n");
+  printf ("  -h          print this command line option summary\n");
+  printf ("  -c CORE     prints the unsatisfiable core to the file CORE (DIMACS format)\n");
+  printf ("  -a ACTIVE   prints the active clauses to the file ACTIVE (DIMACS format)\n");
+  printf ("  -l LEMMAS   prints the core lemmas to the file LEMMAS (DRAT format)\n");
+  printf ("  -L LEMMAS   prints the core lemmas to the file LEMMAS (LRAT format)\n");
+  printf ("  -r TRACE    resolution graph in the TRACE file (TRACECHECK format)\n\n");
+  printf ("  -t <lim>    time limit in seconds (default %i)\n", TIMEOUT);
+  printf ("  -u          default unit propatation (i.e., no core-first)\n");
+  printf ("  -f          forward mode for UNSAT\n");
+  printf ("  -v          more verbose output\n");
+  printf ("  -b          show progress bar\n");
+  printf ("  -O          optimize proof till fixpoint by repeating verification\n");
+  printf ("  -C          compress core lemmas (emit binary proof)\n");
+  printf ("  -D          delete proof file after parsing\n");
+  printf ("  -w          suppress warning messages\n");
+  printf ("  -W          exit after first warning\n");
+  printf ("  -p          run in plain mode (i.e., ignore deletion information)\n\n");
+  printf ("  -R          turn off reduce mode\n\n");
+  printf ("  -S          run in SAT check mode (forward checking)\n\n");
+  printf ("and input and proof are specified as follows\n\n");
+  printf ("  INPUT       input file in DIMACS format\n");
+  printf ("  PROOF       proof file in DRAT format (stdin if no argument)\n\n");
+  exit (0); }
+
+int main (int argc, char** argv) {
+  struct solver S;
+
+  S.inputFile  = NULL;
+  S.proofFile  = stdin;
+  S.coreStr    = NULL;
+  S.activeFile = NULL;
+  S.lemmaStr   = NULL;
+  S.lratFile   = NULL;
+  S.traceFile  = NULL;
+  S.timeout    = TIMEOUT;
+  S.nReads     = 0;
+  S.nWrites    = 0;
+  S.mask       = 0;
+  S.verb       = 0;
+  S.delProof   = 0;
+  S.backforce  = 0;
+  S.optimize   = 0;
+  S.warning    = 0;
+  S.prep       = 0;
+  S.bar        = 0;
+  S.mode       = BACKWARD_UNSAT;
+  S.delete     = 1;
+  S.reduce     = 1;
+  S.binMode    = 0;
+  S.binOutput  = 0;
+  gettimeofday (&S.start_time, NULL);
+
+  int i, tmp = 0;
+  for (i = 1; i < argc; i++) {
+    if        (argv[i][0] == '-') {
+      if      (argv[i][1] == 'h') printHelp ();
+      else if (argv[i][1] == 'c') S.coreStr    = argv[++i];
+      else if (argv[i][1] == 'a') S.activeFile = fopen (argv[++i], "w");
+      else if (argv[i][1] == 'l') S.lemmaStr   = argv[++i];
+      else if (argv[i][1] == 'L') S.lratFile   = fopen (argv[++i], "w");
+      else if (argv[i][1] == 'r') S.traceFile  = fopen (argv[++i], "w");
+      else if (argv[i][1] == 't') S.timeout    = atoi (argv[++i]);
+      else if (argv[i][1] == 'b') S.bar        = 1;
+      else if (argv[i][1] == 'B') S.backforce  = 1;
+      else if (argv[i][1] == 'O') S.optimize   = 1;
+      else if (argv[i][1] == 'C') S.binOutput  = 1;
+      else if (argv[i][1] == 'D') S.delProof   = 1;
+      else if (argv[i][1] == 'u') S.mask       = 1;
+      else if (argv[i][1] == 'v') S.verb       = 1;
+      else if (argv[i][1] == 'w') S.warning    = NOWARNING;
+      else if (argv[i][1] == 'W') S.warning    = HARDWARNING;
+      else if (argv[i][1] == 'p') S.delete     = 0;
+      else if (argv[i][1] == 'R') S.reduce     = 0;
+      else if (argv[i][1] == 'f') S.mode       = FORWARD_UNSAT;
+      else if (argv[i][1] == 'S') S.mode       = FORWARD_SAT; }
+    else {
+      tmp++;
+      if (tmp == 1) {
+        S.inputFile = fopen (argv[1], "r");
+        if (S.inputFile == NULL) {
+          printf ("c error opening \"%s\".\n", argv[i]); return ERROR; } }
+
+      else if (tmp == 2) {
+        S.proofFile = fopen (argv[2], "r");
+        if (S.proofFile == NULL) {
+          printf ("c error opening \"%s\".\n", argv[i]); return ERROR; }
+
+        int j;
+        for (j = 0; j < 10; j++) {
+          int c = getc_unlocked (S.proofFile);
+          if (c == EOF) break;
+          if ((c != 100) && (c != 10) && (c != 13) && (c != 32) && (c != 45) && ((c < 48) || (c > 57)) && ((c < 65) || (c > 122)))  {
+            printf ("c turning on binary mode checking\n");
+            S.binMode = 1; break; } }
+        fclose (S.proofFile);
+        S.proofFile = fopen (argv[2], "r");
+        if (S.proofFile == NULL) {
+          printf ("c error opening \"%s\".\n", argv[i]); return ERROR; } } } }
+
+  if (tmp == 1) printf ("c reading proof from stdin\n");
+  if (tmp == 0) printHelp ();
+
+  int parseReturnValue = parse (&S);
+
+  fclose (S.inputFile);
+  fclose (S.proofFile);
+
+  if (S.mode == FORWARD_UNSAT) {
+    S.reduce = 0; }
+
+  if (S.delProof && argv[2] != NULL) {
+    int ret = remove(argv[2]);
+    if (ret == 0) printf("c deleted proof %s\n", argv[2]); }
+
+  int sts = ERROR;
+  if       (parseReturnValue == ERROR)          printf ("s MEMORY ALLOCATION ERROR\n");
+  else if  (parseReturnValue == UNSAT)          printf ("c trivial UNSAT\ns VERIFIED\n"), sts = UNSAT;
+  else if  ((sts = verify (&S, -1, -1)) == UNSAT) printf ("s VERIFIED\n");
+  else printf ("s NOT VERIFIED\n")  ;
+  struct timeval current_time;
+  gettimeofday (&current_time, NULL);
+  long runtime = (current_time.tv_sec  - S.start_time.tv_sec) * 1000000 +
+                 (current_time.tv_usec - S.start_time.tv_usec);
+  printf ("c verification time: %.3f seconds\n", (double) (runtime / 1000000.0));
+
+  if (S.optimize) {
+    printf("c proof optimization started (ignoring the timeout)\n");
+    int iteration = 1;
+//    while (iteration < 20) {
+    while (S.nRemoved) {
+      deactivate (&S);
+      shuffleProof (&S, iteration);
+      iteration++;
+      verify (&S, 0, 0); } }
+
+  freeMemory (&S);
+  return (sts != UNSAT); // 0 on success, 1 on any failure
+}
diff --git a/hCaD_V2/test/cnf/empty.sol b/hCaD_V2/test/cnf/empty.sol
new file mode 100644
index 0000000..f9eab33
--- /dev/null
+++ b/hCaD_V2/test/cnf/empty.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 0
diff --git a/hCaD_V2/test/cnf/makefile b/hCaD_V2/test/cnf/makefile
new file mode 100644
index 0000000..370c9eb
--- /dev/null
+++ b/hCaD_V2/test/cnf/makefile
@@ -0,0 +1,3 @@
+# execute CNF tests with a single 'make' command in '../../build'
+test:
+	$(MAKE) -C .. cnf
diff --git a/hCaD_V2/test/cnf/precochk.c b/hCaD_V2/test/cnf/precochk.c
new file mode 100644
index 0000000..b48b4fe
--- /dev/null
+++ b/hCaD_V2/test/cnf/precochk.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2009, Armin Biere, JKU, Linz, Austria.  All rights reserved.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <zlib.h>
+#include <string.h>
+#include <assert.h>
+
+static void
+die (const char * msg, ...)
+{
+  va_list ap;
+  fputs ("*** precochk: ", stdout);
+  va_start (ap, msg);
+  vfprintf (stdout, msg, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  exit (1);
+}
+
+static void
+msg (const char * msg, ...)
+{
+  va_list ap;
+  fputs ("c [precochk] ", stdout);
+  va_start (ap, msg);
+  vprintf (msg, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+int
+main (int argc, char ** argv)
+{
+  int m, n, ch, lit, sign, c, sat, l, * stack, * top, * end;
+  signed char * vals, * mark;
+  gzFile dimacs, solution;
+  if (argc != 3) die ("usage: precochk <dimacs> <solution>");
+  if (!(solution = gzopen (argv[2], "r"))) die ("can not read '%s'", argv[2]);
+  msg ("searching solution line in '%s'", argv[2]);
+SKIP1:
+  ch = gzgetc (solution);
+  if (ch == EOF) die ("missing solution line");
+  if (ch == 'c')
+    {
+      while ((ch = gzgetc (solution)) != '\n' && ch != EOF)
+	;
+      goto SKIP1;
+    }
+  if (ch != 's') die ("expected 'c' or 's'");
+  if (gzgetc (solution) != ' ') die ("invalid solution line");
+  ch = gzgetc (solution);
+  if ((ch != 'S' && ch != 'U') ||
+      (ch == 'S' && (gzgetc (solution) != 'A' ||
+		     gzgetc (solution) != 'T' ||
+		     gzgetc (solution) != 'I' ||
+		     gzgetc (solution) != 'S' ||
+		     gzgetc (solution) != 'F' ||
+		     gzgetc (solution) != 'I' ||
+		     gzgetc (solution) != 'A' ||
+		     gzgetc (solution) != 'B' ||
+		     gzgetc (solution) != 'L' ||
+		     gzgetc (solution) != 'E')) ||
+      (ch == 'U' && (gzgetc (solution) != 'N' ||
+		     gzgetc (solution) != 'S' ||
+		     gzgetc (solution) != 'A' ||
+		     gzgetc (solution) != 'T' ||
+		     gzgetc (solution) != 'I' ||
+		     gzgetc (solution) != 'S' ||
+		     gzgetc (solution) != 'F' ||
+		     gzgetc (solution) != 'I' ||
+		     gzgetc (solution) != 'A' ||
+		     gzgetc (solution) != 'B' ||
+		     gzgetc (solution) != 'L' ||
+		     gzgetc (solution) != 'E')) ||
+       gzgetc (solution) != '\n') die ("invalid solution line");
+  msg ("found solution line 's %sSATISFIABLE'", ch == 'S' ? "" : "UN");
+  if (ch == 'U')
+    {
+      msg ("unsatisfiable thus nothing to be done");
+      gzclose (solution);
+      exit (20);
+    }
+  msg ("searching dimacs header in '%s'", argv[1]);
+  if (!(dimacs = gzopen (argv[1], "r"))) die ("can not read '%s'", argv[1]);
+SKIP2:
+  ch = gzgetc (dimacs);
+  if (ch == EOF) die ("missing dimacs header");
+  if (ch == 'c')
+    {
+      while ((ch = gzgetc (dimacs)) != '\n' && ch != EOF)
+	;
+      goto SKIP2;
+    }
+  if (ch != 'p') die ("expected 'c' or 'p'");
+  if (gzgetc (dimacs) != ' ' ||
+      gzgetc (dimacs) != 'c' ||
+      gzgetc (dimacs) != 'n' ||
+      gzgetc (dimacs) != 'f' ||
+      gzgetc (dimacs) != ' ') die ("invalid header");
+  ch = gzgetc (dimacs);
+  if (!isdigit (ch)) die ("invalid header");
+  m = ch - '0';
+  while (isdigit (ch = gzgetc (dimacs)))
+    m = 10  * m + (ch - '0');
+  if (ch != ' ') die ("invalid header");
+  ch = gzgetc (dimacs);
+  if (!isdigit (ch)) die ("invalid header");
+  n = ch - '0';
+  while (isdigit (ch = gzgetc (dimacs)))
+    n = 10 * n + (ch - '0');
+  if (ch != ' ' && ch != '\n') die ("invalid header");
+  msg ("found dimacs header 'p cnf %d %d'", m , n);
+  vals = malloc (m + 1);
+  memset (vals + 1, 0, m);
+  msg ("searching for values in '%s'", argv[2]);
+  c = 0;
+SKIP3:
+  ch = gzgetc (solution);
+  if (ch == EOF) 
+    { 
+      if (c) die ("zero value sentinel missing");
+      else die ("no values found");
+    }
+  if (ch == 'c')
+    {
+      while ((ch = gzgetc (solution)) != '\n' && ch != EOF)
+	;
+      goto SKIP3;
+    }
+  if (ch != 'v') die ("expected 'c' or 'v'");
+  if (gzgetc (solution) != ' ') die ("invalid value line");
+  ch = gzgetc (solution);
+VAL:
+  if (ch == '-')
+    {
+      sign = -1;
+      ch = gzgetc (solution);
+      if (ch == '0') die ("expected non zero digit");
+    }
+  else 
+    sign = 1;
+  if (!isdigit (ch)) die ("expected digit");
+  lit = ch - '0';
+  while (isdigit (ch = gzgetc (solution)))
+    lit = 10 * lit + (ch - '0');
+  if (ch != ' ' && ch != '\n') die ("expected space or new line");
+  if (!lit) goto CHECK;
+  if (lit > m) die ("value %d exceeds maximal index %d", sign * lit, m);
+  if (vals[lit]) die ("multiple values for %d", lit);
+  vals[lit] = sign;
+  c++;
+  while (ch == ' ')
+    ch = gzgetc (solution);
+  if (ch == '\n') goto SKIP3;
+  goto VAL;
+CHECK:
+  assert (c <= m);
+  if (c == m) msg ("found all %d values", c);
+  else msg ("found %d out of %d values (%d missing)", c, m, m - c);
+  mark = malloc (m + 1);
+  memset (mark + 1, 0, m);
+  stack = top = end = 0;
+SKIP4:
+  ch = gzgetc (solution);
+  if (ch == 'c') 
+    {
+      while ((ch = gzgetc (solution)) != '\n' && ch != EOF)
+	;
+      goto SKIP4;
+    }
+  if (ch == 'v') die ("invalid new value block");
+  if (ch != EOF) die ("invalid line after values");
+  gzclose (solution);
+  msg ("solution file closed");
+  sat = c = l = 0;
+LIT:
+  ch = gzgetc (dimacs);
+  if (ch == ' ' || ch == '\n') goto LIT;
+  if (ch == 'c')
+    {
+      while ((ch = gzgetc (dimacs)) != '\n' && ch != EOF)
+	;
+      goto LIT;
+    }
+  if (ch == EOF)
+    {
+      if (l) die ("zero literal sentinel missing");
+      if (c < n) die ("clauses missing");
+      goto DONE;
+    }
+  if (ch == '-')
+    {
+      sign = -1;
+      ch = gzgetc (dimacs);
+      if (ch == '0') die ("expected non zero digit");
+    }
+  else
+    sign = 1;
+  if (!isdigit (ch)) die ("expected digit");
+  if (c == n) die ("too many clauses");
+  lit = ch - '0';
+  while (isdigit (ch = gzgetc (dimacs)))
+    lit = 10 * lit + (ch - '0');
+  if (ch != ' ' && ch != '\n') die ("expected space or new line");
+  if (lit) 
+    {
+      l++;
+      if (!sat)
+	{
+	  if (vals[lit] == sign || mark[lit] == -sign)
+	    sat = 1;
+	  else 
+	    {
+	      if (top == end)
+		{
+		  int count = top - stack, size = count ? 2 * count : 1;
+		  stack = realloc (stack, size * sizeof (int));
+		  top = stack + count;
+		  end = stack + size;
+		}
+
+	      *top++ = lit;
+	      mark[lit] = sign;
+	    }
+	}
+    }
+  else
+    {
+      c++;
+      if (!sat) die ("clause %d unsatisfied", c);
+      l = sat = 0;
+      while (top > stack)
+	mark[*--top] = 0;
+    }
+  goto LIT;
+DONE:
+  assert (c == n);
+  gzclose (dimacs);
+  free (vals);
+  free (stack);
+  free (mark);
+  msg ("checked %d clauses", c);
+  msg ("satisfiable and solution correct", c);
+  return 0;
+}
diff --git a/hCaD_V2/test/cnf/prime121.sol b/hCaD_V2/test/cnf/prime121.sol
new file mode 100644
index 0000000..f5ca8fe
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime121.sol
@@ -0,0 +1,20 @@
+s SATISFIABLE
+v 1 2 -3 4 -5 -6 7 8 -9 10 -11 -12 13 -14 -15 -16 -17 18 -19 -20 -21 -22 23 24
+v 25 26 27 -28 -29 -30 -31 32 -33 -34 35 -36 37 -38 -39 40 -41 42 43 -44 -45 46
+v -47 -48 -49 50 -51 52 -53 -54 -55 -56 -57 58 -59 60 -61 -62 -63 64 -65 -66 67
+v -68 69 -70 -71 -72 -73 74 -75 76 -77 -78 79 -80 -81 82 -83 -84 85 -86 87 -88
+v 89 90 -91 -92 -93 -94 95 -96 -97 98 -99 -100 -101 -102 103 -104 -105 -106 107
+v -108 -109 -110 111 -112 113 -114 -115 116 -117 -118 119 -120 -121 122 -123
+v -124 -125 -126 127 -128 -129 130 -131 -132 133 -134 -135 -136 137 -138 -139
+v 140 -141 -142 143 -144 145 -146 -147 148 -149 150 -151 -152 -153 -154 -155
+v 156 -157 -158 159 -160 161 -162 163 -164 -165 -166 167 168 -169 -170 -171
+v -172 173 -174 -175 -176 -177 178 -179 -180 181 -182 -183 184 -185 -186 -187
+v 188 -189 -190 191 -192 193 -194 -195 196 -197 -198 199 -200 201 -202 -203
+v -204 -205 -206 207 -208 -209 210 -211 212 -213 -214 -215 -216 -217 218 -219
+v -220 221 -222 223 -224 -225 -226 -227 -228 229 -230 -231 232 -233 234 -235
+v 236 -237 -238 239 -240 241 -242 -243 244 -245 -246 247 -248 249 -250 -251 252
+v -253 -254 255 -256 -257 258 -259 260 -261 -262 263 -264 -265 266 -267 -268
+v 269 -270 271 -272 273 -274 -275 276 -277 278 -279 -280 281 -282 -283 284 -285
+v 286 -287 -288 289 -290 -291 292 -293 -294 295 -296 297 -298 299 -300 -301 302
+v -303 304 -305 -306 307 308 -309 -310 311 -312 -313 314 -315 316 -317 318 319
+v 320 321 322 323 324 325 326 327 328 329 0
diff --git a/hCaD_V2/test/cnf/prime1369.sol b/hCaD_V2/test/cnf/prime1369.sol
new file mode 100644
index 0000000..f44cbdf
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime1369.sol
@@ -0,0 +1,61 @@
+s SATISFIABLE
+v 1 -2 3 -4 -5 6 -7 -8 -9 -10 11 -12 13 -14 -15 16 -17 -18 -19 -20 21 22 23 -24
+v -25 -26 -27 -28 -29 30 31 32 -33 -34 -35 -36 -37 -38 39 40 -41 -42 -43 44 -45
+v 46 47 -48 -49 -50 51 -52 -53 54 55 -56 -57 -58 -59 -60 -61 -62 -63 64 -65 -66
+v 67 -68 69 -70 -71 -72 73 -74 -75 -76 77 -78 -79 80 -81 -82 -83 84 -85 -86 87
+v -88 -89 90 -91 92 -93 94 95 -96 -97 98 99 -100 -101 -102 -103 104 -105 -106
+v -107 108 -109 -110 111 -112 -113 114 115 116 -117 118 -119 -120 121 -122 -123
+v 124 -125 -126 127 -128 -129 -130 -131 132 -133 -134 135 -136 -137 138 -139
+v -140 -141 -142 143 -144 -145 146 -147 -148 149 -150 -151 -152 153 -154 -155
+v 156 157 -158 -159 -160 -161 -162 -163 -164 -165 166 -167 -168 169 -170 171
+v -172 -173 -174 -175 -176 177 -178 -179 180 -181 182 -183 -184 -185 -186 -187
+v 188 -189 -190 191 -192 193 -194 -195 -196 -197 -198 199 -200 -201 202 -203
+v 204 -205 -206 -207 208 -209 -210 -211 212 -213 -214 215 -216 -217 -218 219
+v -220 -221 222 -223 -224 225 -226 227 -228 229 230 -231 -232 233 234 -235 -236
+v -237 -238 239 -240 241 -242 -243 244 -245 -246 247 -248 -249 250 -251 252
+v -253 -254 255 -256 -257 258 -259 -260 261 262 263 -264 -265 266 267 -268 -269
+v 270 -271 -272 -273 -274 -275 276 -277 278 -279 -280 281 -282 -283 -284 -285
+v 286 -287 -288 289 -290 -291 292 -293 294 -295 -296 -297 -298 -299 300 -301
+v -302 303 -304 305 -306 -307 -308 -309 -310 311 -312 -313 314 -315 316 -317
+v -318 -319 -320 -321 322 -323 -324 325 -326 327 -328 -329 -330 -331 332 -333
+v -334 335 -336 -337 -338 339 -340 341 -342 -343 344 -345 -346 347 -348 -349
+v 350 -351 -352 -353 354 -355 -356 357 -358 -359 360 -361 -362 -363 364 -365
+v -366 367 -368 -369 370 -371 372 -373 -374 375 -376 -377 378 -379 -380 381
+v -382 383 -384 -385 386 -387 -388 389 -390 -391 392 -393 394 -395 -396 397
+v -398 -399 400 -401 -402 403 -404 405 -406 -407 408 -409 -410 411 -412 -413
+v 414 -415 416 -417 -418 -419 -420 -421 422 -423 -424 425 -426 427 -428 -429
+v -430 -431 -432 433 -434 -435 436 -437 438 -439 -440 -441 -442 443 -444 445
+v -446 -447 448 -449 -450 451 -452 -453 454 -455 456 -457 -458 459 -460 -461
+v 462 -463 -464 465 -466 467 -468 -469 470 -471 -472 473 -474 -475 476 -477 478
+v -479 -480 481 -482 -483 484 -485 -486 487 -488 489 -490 491 492 -493 -494 495
+v 496 -497 -498 -499 -500 501 -502 503 -504 -505 506 -507 -508 509 -510 -511
+v 512 -513 514 -515 -516 517 -518 -519 520 -521 -522 523 -524 525 -526 -527 528
+v -529 -530 531 -532 -533 534 -535 -536 -537 538 -539 -540 541 -542 543 -544
+v -545 546 -547 -548 549 -550 551 -552 -553 554 -555 -556 557 -558 -559 560
+v -561 562 -563 -564 565 -566 -567 568 -569 -570 571 -572 573 -574 -575 -576
+v -577 -578 579 -580 -581 582 -583 584 -585 -586 -587 -588 -589 590 -591 -592
+v 593 -594 595 -596 -597 -598 -599 -600 601 -602 -603 604 -605 606 -607 -608
+v -609 -610 -611 612 -613 -614 615 -616 617 -618 -619 -620 -621 -622 623 -624
+v -625 626 -627 628 -629 630 -631 -632 633 -634 635 -636 -637 638 -639 -640 641
+v -642 643 -644 -645 646 -647 -648 649 -650 -651 652 -653 654 -655 -656 657
+v -658 -659 660 -661 -662 663 -664 665 -666 -667 668 -669 -670 671 -672 -673
+v 674 -675 676 -677 -678 679 -680 -681 682 -683 -684 685 -686 687 -688 -689 690
+v -691 -692 693 -694 -695 696 -697 698 -699 -700 701 -702 -703 704 -705 -706
+v 707 -708 709 -710 711 -712 -713 714 -715 716 -717 -718 719 -720 -721 722 -723
+v 724 -725 -726 727 -728 -729 730 -731 -732 733 -734 735 -736 -737 738 -739
+v -740 741 -742 -743 744 -745 746 -747 -748 749 -750 -751 752 -753 -754 755
+v -756 757 -758 -759 760 -761 -762 763 -764 -765 766 -767 768 -769 -770 771
+v -772 -773 774 -775 -776 777 -778 779 -780 781 -782 -783 784 -785 786 -787
+v -788 789 -790 -791 792 -793 794 -795 -796 797 -798 -799 800 -801 -802 803
+v -804 805 -806 -807 808 -809 -810 811 -812 -813 814 -815 816 -817 -818 819
+v -820 -821 822 -823 -824 825 -826 827 -828 -829 830 -831 -832 833 -834 -835
+v 836 -837 838 -839 840 -841 -842 843 -844 845 -846 -847 848 -849 -850 851 -852
+v 853 -854 -855 856 -857 -858 859 -860 -861 862 -863 864 -865 -866 867 -868
+v -869 870 -871 -872 873 -874 875 -876 -877 878 -879 -880 881 -882 -883 884
+v -885 886 -887 888 -889 -890 891 -892 893 -894 -895 896 -897 -898 899 -900 901
+v -902 -903 904 -905 -906 907 -908 -909 910 -911 912 -913 -914 915 -916 -917
+v 918 -919 -920 921 -922 923 -924 925 -926 -927 928 -929 930 -931 -932 933 -934
+v -935 936 -937 938 -939 -940 941 -942 -943 944 -945 -946 947 -948 949 -950 951
+v -952 -953 954 -955 956 -957 -958 959 960 -961 -962 963 -964 -965 966 -967 968
+v -969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
+v 988 989 0
diff --git a/hCaD_V2/test/cnf/prime1681.sol b/hCaD_V2/test/cnf/prime1681.sol
new file mode 100644
index 0000000..5b3637c
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime1681.sol
@@ -0,0 +1,61 @@
+s SATISFIABLE
+v 1 -2 -3 4 -5 6 -7 -8 -9 -10 11 -12 -13 14 -15 16 -17 -18 -19 -20 21 22 23 -24
+v -25 -26 -27 -28 -29 30 31 32 -33 -34 -35 -36 -37 -38 39 40 -41 -42 -43 44 -45
+v -46 -47 -48 -49 -50 51 -52 53 -54 -55 56 -57 58 59 -60 61 -62 -63 64 -65 -66
+v 67 -68 -69 70 -71 -72 -73 74 -75 -76 77 78 -79 -80 -81 -82 -83 -84 -85 -86 87
+v -88 -89 90 -91 92 -93 -94 -95 -96 -97 98 -99 -100 101 -102 103 -104 -105 -106
+v 107 -108 -109 -110 111 -112 -113 114 115 116 -117 118 -119 -120 121 -122 -123
+v 124 -125 -126 127 -128 129 -130 -131 132 -133 -134 135 -136 -137 138 -139 140
+v -141 -142 143 -144 -145 146 -147 -148 149 -150 -151 -152 153 -154 -155 156
+v 157 -158 -159 -160 -161 -162 -163 -164 -165 166 -167 -168 169 -170 171 -172
+v -173 -174 -175 -176 177 -178 -179 180 -181 182 -183 184 -185 -186 -187 188
+v 189 -190 -191 -192 -193 194 -195 -196 -197 -198 199 -200 -201 202 -203 -204
+v 205 -206 -207 208 -209 210 -211 -212 -213 214 -215 -216 -217 -218 219 -220
+v -221 222 -223 -224 225 -226 227 -228 -229 230 -231 -232 233 -234 -235 236
+v -237 238 -239 -240 -241 -242 -243 244 -245 -246 247 -248 249 -250 -251 -252
+v -253 -254 255 -256 -257 258 -259 260 -261 -262 -263 264 -265 -266 -267 268
+v -269 -270 -271 272 -273 -274 -275 276 -277 -278 279 -280 -281 282 -283 -284
+v -285 286 -287 -288 289 -290 -291 292 -293 294 -295 -296 297 -298 -299 300
+v -301 -302 303 -304 305 -306 307 308 -309 -310 311 312 -313 -314 -315 -316 317
+v -318 319 -320 -321 322 -323 -324 325 -326 -327 328 329 330 -331 -332 333 334
+v -335 -336 337 -338 -339 -340 -341 -342 -343 344 -345 -346 347 -348 349 -350
+v -351 -352 -353 354 -355 356 -357 -358 359 -360 -361 -362 -363 364 -365 -366
+v 367 -368 -369 370 -371 372 -373 -374 375 -376 -377 378 -379 -380 381 -382 383
+v -384 -385 -386 -387 -388 389 -390 -391 392 -393 394 -395 -396 -397 -398 -399
+v 400 -401 -402 403 -404 405 -406 -407 -408 -409 410 -411 -412 413 -414 -415
+v -416 417 -418 419 -420 -421 422 -423 -424 425 -426 -427 428 -429 430 -431
+v -432 433 -434 -435 436 -437 -438 439 -440 -441 -442 443 -444 -445 446 -447
+v -448 449 -450 451 -452 -453 454 -455 456 -457 -458 459 -460 -461 462 -463
+v -464 465 -466 467 -468 -469 470 -471 -472 473 -474 -475 476 -477 478 -479
+v -480 481 -482 -483 484 -485 -486 487 -488 489 -490 491 492 -493 -494 495 496
+v -497 -498 -499 -500 501 -502 -503 -504 -505 506 -507 -508 509 -510 -511 512
+v -513 -514 -515 -516 517 -518 -519 520 -521 -522 523 -524 -525 -526 -527 528
+v -529 -530 531 -532 -533 534 -535 -536 -537 538 -539 -540 541 -542 543 -544
+v -545 546 -547 -548 549 -550 551 -552 -553 554 -555 -556 557 -558 -559 560
+v -561 562 -563 -564 565 -566 -567 568 -569 -570 571 -572 573 -574 -575 -576
+v -577 -578 579 -580 -581 582 -583 584 -585 -586 -587 -588 -589 590 -591 -592
+v 593 -594 595 -596 -597 -598 -599 -600 601 -602 -603 604 -605 606 -607 -608
+v -609 -610 -611 612 -613 -614 615 -616 617 -618 -619 -620 -621 -622 623 -624
+v -625 626 -627 628 -629 630 -631 -632 633 -634 635 -636 -637 638 -639 -640 641
+v -642 643 -644 -645 646 -647 -648 649 -650 -651 652 -653 654 -655 -656 657
+v -658 -659 660 -661 -662 663 -664 665 -666 -667 668 -669 -670 671 -672 -673
+v 674 -675 676 -677 -678 679 -680 -681 682 -683 -684 685 -686 687 -688 -689 690
+v -691 -692 693 -694 -695 696 -697 698 -699 -700 701 -702 -703 704 -705 -706
+v 707 -708 709 -710 711 -712 -713 714 -715 716 -717 -718 719 -720 -721 722 -723
+v 724 -725 -726 727 -728 -729 730 -731 -732 733 -734 735 -736 -737 738 -739
+v -740 741 -742 -743 744 -745 746 -747 -748 749 -750 -751 752 -753 -754 755
+v -756 757 -758 -759 760 -761 -762 763 -764 -765 766 -767 768 -769 -770 771
+v -772 -773 774 -775 -776 777 -778 779 -780 781 -782 -783 784 -785 786 -787
+v -788 789 -790 -791 792 -793 794 -795 -796 797 -798 -799 800 -801 -802 803
+v -804 805 -806 -807 808 -809 -810 811 -812 -813 814 -815 816 -817 -818 819
+v -820 -821 822 -823 -824 825 -826 827 -828 -829 830 -831 -832 833 -834 -835
+v 836 -837 838 -839 840 -841 -842 843 -844 845 -846 -847 848 -849 -850 851 -852
+v 853 -854 -855 856 -857 -858 859 -860 -861 862 -863 864 -865 -866 867 -868
+v -869 870 -871 -872 873 -874 875 -876 -877 878 -879 -880 881 -882 -883 884
+v -885 886 -887 888 -889 -890 891 -892 893 -894 -895 896 -897 -898 899 -900 901
+v -902 -903 904 -905 -906 907 -908 -909 910 -911 912 -913 -914 915 -916 -917
+v 918 -919 -920 921 -922 923 -924 925 -926 -927 928 -929 930 -931 -932 933 -934
+v -935 936 -937 938 -939 -940 941 -942 -943 944 -945 -946 947 -948 949 -950 951
+v -952 -953 954 -955 956 -957 -958 959 960 -961 -962 963 -964 -965 966 -967 968
+v -969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
+v 988 989 0
diff --git a/hCaD_V2/test/cnf/prime169.sol b/hCaD_V2/test/cnf/prime169.sol
new file mode 100644
index 0000000..747ef81
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime169.sol
@@ -0,0 +1,28 @@
+s SATISFIABLE
+v 1 -2 3 4 -5 -6 -7 8 -9 10 11 -12 -13 -14 15 16 -17 -18 -19 -20 21 22 -23 -24
+v -25 -26 27 28 -29 -30 -31 32 -33 34 35 -36 -37 -38 39 -40 -41 42 43 -44 -45
+v 46 47 -48 -49 -50 -51 52 -53 -54 55 -56 -57 58 -59 -60 61 -62 63 -64 -65 -66
+v -67 68 -69 -70 -71 -72 -73 -74 75 -76 -77 78 -79 80 -81 82 -83 84 -85 -86 -87
+v -88 89 -90 91 -92 -93 -94 -95 96 -97 98 -99 -100 101 -102 -103 -104 -105 106
+v -107 -108 109 -110 -111 112 -113 114 -115 116 -117 118 -119 -120 -121 -122
+v 123 -124 125 -126 127 128 -129 -130 131 132 -133 -134 -135 -136 137 -138 -139
+v -140 141 -142 -143 144 -145 -146 147 -148 -149 -150 151 -152 -153 154 -155
+v -156 157 -158 159 -160 -161 -162 163 -164 -165 -166 167 -168 -169 -170 171
+v 172 -173 -174 -175 176 177 -178 -179 180 -181 -182 -183 -184 -185 -186 187
+v -188 -189 190 -191 192 -193 -194 -195 -196 197 -198 199 -200 -201 202 -203
+v -204 205 -206 -207 208 -209 210 -211 -212 213 -214 -215 216 -217 -218 219
+v -220 221 -222 -223 -224 -225 226 -227 -228 229 -230 -231 -232 233 -234 235
+v -236 -237 238 -239 -240 241 -242 -243 244 -245 246 -247 -248 249 -250 -251
+v 252 -253 -254 255 -256 -257 -258 259 -260 -261 262 -263 264 -265 -266 267
+v -268 -269 270 -271 272 -273 -274 275 -276 -277 278 -279 -280 281 -282 283
+v -284 -285 -286 -287 -288 289 -290 -291 292 -293 294 -295 -296 -297 -298 -299
+v 300 -301 -302 303 -304 305 -306 -307 -308 -309 -310 311 -312 -313 314 -315
+v 316 -317 318 -319 -320 321 -322 323 -324 -325 326 -327 -328 329 -330 331 -332
+v -333 334 -335 -336 337 -338 -339 340 -341 342 -343 -344 345 -346 -347 348
+v -349 -350 351 -352 353 -354 -355 356 -357 -358 359 -360 -361 362 -363 364
+v -365 366 -367 -368 369 -370 371 -372 -373 374 -375 -376 377 -378 379 -380
+v -381 382 -383 -384 385 -386 -387 388 -389 390 -391 -392 393 -394 -395 396
+v -397 -398 399 -400 401 -402 403 -404 -405 406 -407 408 -409 -410 411 -412
+v -413 414 -415 416 -417 -418 419 -420 -421 422 -423 -424 425 -426 427 -428 429
+v -430 -431 432 -433 434 -435 -436 437 438 -439 -440 441 -442 -443 444 -445 446
+v -447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 0
diff --git a/hCaD_V2/test/cnf/prime1849.sol b/hCaD_V2/test/cnf/prime1849.sol
new file mode 100644
index 0000000..2e695fd
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime1849.sol
@@ -0,0 +1,61 @@
+s SATISFIABLE
+v 1 2 -3 4 -5 6 -7 -8 -9 -10 11 12 -13 14 -15 16 -17 -18 -19 -20 21 22 23 -24
+v -25 -26 -27 -28 -29 30 31 32 -33 -34 -35 -36 -37 -38 39 40 41 42 43 -44 -45
+v -46 -47 48 -49 -50 51 -52 53 -54 -55 56 -57 58 59 -60 -61 62 -63 -64 -65 66
+v -67 68 -69 -70 -71 -72 -73 74 -75 76 -77 -78 -79 80 -81 -82 83 -84 85 -86 -87
+v -88 -89 90 -91 92 -93 -94 95 -96 -97 98 -99 -100 101 -102 103 -104 105 106
+v -107 -108 -109 -110 111 -112 -113 114 115 116 -117 -118 119 -120 -121 -122
+v 123 -124 125 -126 -127 -128 129 -130 -131 132 -133 -134 135 -136 137 -138
+v -139 -140 -141 -142 143 -144 -145 146 -147 148 -149 -150 -151 -152 153 -154
+v 155 -156 -157 -158 159 -160 -161 162 -163 164 -165 -166 -167 -168 169 -170
+v 171 -172 -173 174 -175 -176 177 -178 -179 180 -181 182 -183 184 185 -186 -187
+v 188 189 -190 -191 -192 -193 194 -195 196 -197 -198 199 -200 -201 202 -203
+v -204 205 206 207 -208 -209 210 -211 -212 -213 214 -215 -216 -217 -218 -219
+v 220 -221 -222 -223 224 -225 -226 -227 228 -229 230 -231 -232 233 -234 -235
+v 236 -237 -238 239 -240 -241 -242 -243 244 -245 -246 247 -248 -249 250 -251
+v -252 -253 -254 255 -256 -257 258 -259 -260 261 -262 -263 -264 265 -266 -267
+v 268 -269 270 -271 -272 -273 -274 -275 276 -277 278 -279 -280 281 -282 -283
+v -284 -285 286 -287 -288 289 -290 -291 292 -293 294 -295 -296 -297 -298 -299
+v 300 -301 -302 303 -304 305 -306 307 -308 -309 -310 311 312 -313 -314 -315
+v -316 317 -318 -319 -320 -321 322 -323 -324 325 -326 -327 328 329 -330 331
+v -332 -333 -334 -335 336 -337 -338 339 -340 341 -342 -343 344 -345 -346 347
+v -348 -349 350 -351 -352 -353 354 -355 -356 357 -358 -359 360 -361 -362 -363
+v 364 -365 -366 367 -368 -369 370 -371 372 -373 -374 375 -376 -377 378 -379
+v -380 381 -382 383 -384 -385 -386 -387 -388 389 -390 -391 392 -393 394 -395
+v -396 -397 -398 -399 400 -401 -402 403 -404 405 -406 -407 -408 409 410 -411
+v -412 413 -414 -415 -416 417 -418 -419 -420 -421 422 -423 -424 425 -426 -427
+v 428 -429 -430 -431 -432 433 -434 -435 436 -437 -438 439 -440 -441 -442 443
+v -444 -445 446 -447 -448 449 -450 451 -452 -453 454 -455 456 -457 -458 459
+v -460 -461 462 -463 -464 465 -466 467 -468 -469 470 -471 -472 473 -474 -475
+v 476 -477 478 -479 -480 481 -482 -483 484 -485 -486 487 -488 489 -490 491 492
+v -493 -494 495 496 -497 -498 -499 -500 501 -502 -503 -504 -505 506 -507 -508
+v 509 -510 -511 512 -513 -514 -515 -516 517 -518 -519 520 -521 -522 523 -524
+v -525 -526 -527 528 -529 -530 531 -532 -533 534 -535 -536 -537 538 -539 -540
+v 541 -542 543 -544 -545 546 -547 -548 549 -550 551 -552 -553 554 -555 -556 557
+v -558 -559 560 -561 562 -563 -564 565 -566 -567 568 -569 -570 571 -572 573
+v -574 -575 -576 -577 -578 579 -580 -581 582 -583 584 -585 -586 -587 -588 -589
+v 590 -591 -592 593 -594 595 -596 -597 -598 -599 -600 601 -602 -603 604 -605
+v 606 -607 -608 -609 -610 -611 612 -613 -614 615 -616 617 -618 -619 -620 -621
+v -622 623 -624 -625 626 -627 628 -629 630 -631 -632 633 -634 635 -636 -637 638
+v -639 -640 641 -642 643 -644 -645 646 -647 -648 649 -650 -651 652 -653 654
+v -655 -656 657 -658 -659 660 -661 -662 663 -664 665 -666 -667 668 -669 -670
+v 671 -672 -673 674 -675 676 -677 -678 679 -680 -681 682 -683 -684 685 -686 687
+v -688 -689 690 -691 -692 693 -694 -695 696 -697 698 -699 -700 701 -702 -703
+v 704 -705 -706 707 -708 709 -710 711 -712 -713 714 -715 716 -717 -718 719 -720
+v -721 722 -723 724 -725 -726 727 -728 -729 730 -731 -732 733 -734 735 -736
+v -737 738 -739 -740 741 -742 -743 744 -745 746 -747 -748 749 -750 -751 752
+v -753 -754 755 -756 757 -758 -759 760 -761 -762 763 -764 -765 766 -767 768
+v -769 -770 771 -772 -773 774 -775 -776 777 -778 779 -780 781 -782 -783 784
+v -785 786 -787 -788 789 -790 -791 792 -793 794 -795 -796 797 -798 -799 800
+v -801 -802 803 -804 805 -806 -807 808 -809 -810 811 -812 -813 814 -815 816
+v -817 -818 819 -820 -821 822 -823 -824 825 -826 827 -828 -829 830 -831 -832
+v 833 -834 -835 836 -837 838 -839 840 -841 -842 843 -844 845 -846 -847 848 -849
+v -850 851 -852 853 -854 -855 856 -857 -858 859 -860 -861 862 -863 864 -865
+v -866 867 -868 -869 870 -871 -872 873 -874 875 -876 -877 878 -879 -880 881
+v -882 -883 884 -885 886 -887 888 -889 -890 891 -892 893 -894 -895 896 -897
+v -898 899 -900 901 -902 -903 904 -905 -906 907 -908 -909 910 -911 912 -913
+v -914 915 -916 -917 918 -919 -920 921 -922 923 -924 925 -926 -927 928 -929 930
+v -931 -932 933 -934 -935 936 -937 938 -939 -940 941 -942 -943 944 -945 -946
+v 947 -948 949 -950 951 -952 -953 954 -955 956 -957 -958 959 960 -961 -962 963
+v -964 -965 966 -967 968 -969 970 971 972 973 974 975 976 977 978 979 980 981
+v 982 983 984 985 986 987 988 989 0
diff --git a/hCaD_V2/test/cnf/prime2209.sol b/hCaD_V2/test/cnf/prime2209.sol
new file mode 100644
index 0000000..3ceb5b4
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime2209.sol
@@ -0,0 +1,77 @@
+s SATISFIABLE
+v 1 2 3 4 -5 6 -7 -8 -9 -10 -11 12 13 14 15 -16 17 -18 -19 -20 -21 -22 23 24 25
+v 26 -27 -28 -29 -30 -31 -32 33 34 35 36 -37 -38 -39 -40 -41 -42 43 44 45 46 47
+v -48 -49 50 51 52 -53 -54 55 -56 -57 58 59 -60 -61 62 63 64 -65 66 67 -68 -69
+v -70 71 -72 -73 74 75 -76 -77 78 -79 -80 81 82 -83 -84 -85 -86 87 -88 89 90
+v -91 -92 -93 94 -95 96 -97 98 -99 100 101 -102 -103 -104 105 -106 107 -108 109
+v -110 -111 112 -113 114 -115 -116 117 -118 119 120 -121 -122 123 -124 -125
+v -126 127 -128 129 -130 -131 132 -133 134 -135 -136 -137 -138 139 -140 141
+v -142 143 -144 145 -146 -147 -148 -149 150 -151 152 -153 -154 -155 -156 157
+v -158 159 -160 -161 -162 163 -164 -165 166 -167 168 -169 -170 -171 -172 173
+v -174 175 -176 -177 -178 179 -180 -181 -182 183 -184 -185 -186 187 188 -189
+v 190 -191 -192 -193 -194 195 -196 -197 198 -199 200 -201 -202 203 -204 -205
+v 206 -207 -208 209 210 211 -212 -213 214 -215 -216 -217 218 -219 -220 -221
+v -222 -223 224 -225 -226 -227 228 -229 -230 -231 232 233 234 -235 -236 237 238
+v -239 -240 241 -242 -243 -244 -245 246 247 -248 -249 250 -251 -252 -253 254
+v -255 -256 -257 -258 259 -260 -261 262 -263 -264 265 266 -267 -268 269 -270
+v -271 -272 273 -274 -275 276 -277 -278 -279 280 -281 -282 283 -284 -285 286
+v -287 -288 -289 290 -291 -292 293 -294 -295 296 -297 298 -299 -300 -301 -302
+v 303 -304 -305 306 -307 -308 -309 310 311 312 -313 -314 315 316 -317 -318 319
+v -320 -321 -322 -323 -324 -325 326 -327 -328 329 -330 331 -332 333 -334 335
+v 336 -337 -338 -339 340 -341 342 -343 -344 -345 -346 -347 348 -349 -350 351
+v -352 353 -354 -355 -356 -357 358 -359 360 -361 -362 363 -364 -365 -366 -367
+v 368 -369 -370 371 -372 -373 374 -375 376 -377 -378 379 -380 -381 382 -383
+v -384 385 -386 387 -388 -389 -390 -391 392 -393 -394 395 -396 -397 -398 399
+v -400 401 -402 -403 404 -405 -406 407 -408 -409 410 -411 -412 413 -414 -415
+v -416 417 -418 419 -420 -421 -422 423 -424 -425 426 -427 -428 429 -430 431
+v -432 -433 434 -435 -436 437 -438 -439 440 -441 442 -443 -444 -445 -446 447
+v -448 449 -450 -451 452 -453 -454 -455 -456 457 -458 -459 460 -461 -462 463
+v -464 465 -466 -467 468 -469 -470 471 -472 -473 474 -475 476 -477 -478 479
+v -480 -481 482 -483 -484 485 -486 487 -488 -489 -490 -491 -492 493 -494 -495
+v 496 -497 498 -499 500 -501 502 -503 -504 -505 -506 507 -508 509 -510 -511 512
+v -513 -514 515 -516 -517 518 -519 520 -521 -522 523 -524 -525 526 -527 -528
+v 529 -530 531 -532 -533 534 -535 -536 537 -538 -539 540 -541 542 -543 -544
+v -545 -546 547 -548 549 -550 -551 552 -553 -554 555 -556 -557 558 -559 560
+v -561 -562 563 -564 -565 566 -567 -568 569 -570 571 -572 -573 574 -575 -576
+v 577 -578 -579 580 -581 582 -583 -584 585 -586 -587 588 -589 -590 591 -592 593
+v -594 -595 -596 597 -598 -599 -600 601 -602 -603 -604 605 -606 607 -608 -609
+v 610 -611 -612 613 -614 -615 616 -617 618 -619 -620 621 -622 -623 624 -625
+v -626 627 -628 629 -630 -631 632 -633 -634 635 -636 -637 638 -639 640 -641
+v -642 643 -644 -645 646 -647 -648 649 -650 -651 -652 653 -654 -655 656 -657
+v 658 -659 -660 661 -662 -663 664 -665 666 -667 -668 669 -670 -671 672 -673
+v -674 675 -676 677 -678 -679 680 -681 -682 683 -684 -685 686 -687 688 -689
+v -690 691 -692 -693 694 -695 -696 697 -698 699 -700 -701 -702 -703 -704 705
+v -706 -707 708 -709 710 -711 -712 -713 -714 -715 716 -717 -718 719 -720 721
+v -722 -723 -724 -725 -726 727 -728 -729 730 -731 732 -733 -734 -735 -736 -737
+v 738 -739 -740 741 -742 743 -744 -745 -746 -747 -748 749 -750 -751 752 -753
+v 754 -755 756 -757 -758 759 -760 761 -762 -763 764 -765 -766 767 -768 769 -770
+v -771 772 -773 -774 775 -776 -777 778 -779 780 -781 -782 783 -784 -785 786
+v -787 -788 789 -790 791 -792 -793 794 -795 -796 797 -798 -799 800 -801 802
+v -803 -804 805 -806 -807 808 -809 -810 811 -812 813 -814 -815 816 -817 -818
+v 819 -820 -821 822 -823 824 -825 -826 827 -828 -829 830 -831 -832 833 -834 835
+v -836 -837 838 -839 -840 841 -842 -843 844 -845 846 -847 848 -849 -850 851
+v -852 853 -854 -855 856 -857 -858 859 -860 861 -862 -863 864 -865 -866 867
+v -868 -869 870 -871 872 -873 -874 875 -876 -877 878 -879 -880 881 -882 883
+v -884 -885 886 -887 -888 889 -890 -891 892 -893 894 -895 -896 897 -898 -899
+v 900 -901 -902 903 -904 905 -906 -907 908 -909 -910 911 -912 -913 914 -915 916
+v -917 -918 919 -920 -921 922 -923 -924 925 -926 927 -928 929 -930 -931 932
+v -933 934 -935 -936 937 -938 -939 940 -941 942 -943 -944 945 -946 -947 948
+v -949 -950 951 -952 953 -954 -955 956 -957 -958 959 -960 -961 962 -963 964
+v -965 -966 967 -968 -969 970 -971 -972 973 -974 975 -976 -977 978 -979 -980
+v 981 -982 -983 984 -985 986 -987 -988 989 -990 -991 992 -993 -994 995 -996 997
+v -998 999 -1000 -1001 1002 -1003 1004 -1005 -1006 1007 -1008 -1009 1010 -1011
+v 1012 -1013 -1014 1015 -1016 -1017 1018 -1019 -1020 1021 -1022 1023 -1024
+v -1025 1026 -1027 -1028 1029 -1030 -1031 1032 -1033 1034 -1035 -1036 1037
+v -1038 -1039 1040 -1041 -1042 1043 -1044 1045 -1046 -1047 1048 -1049 -1050
+v 1051 -1052 -1053 1054 -1055 1056 -1057 1058 -1059 -1060 1061 -1062 1063 -1064
+v -1065 1066 -1067 -1068 1069 -1070 1071 -1072 -1073 1074 -1075 -1076 1077
+v -1078 -1079 1080 -1081 1082 -1083 -1084 1085 -1086 -1087 1088 -1089 -1090
+v 1091 -1092 1093 -1094 -1095 1096 -1097 -1098 1099 -1100 -1101 1102 -1103 1104
+v -1105 1106 -1107 -1108 1109 -1110 1111 -1112 -1113 1114 -1115 -1116 1117
+v -1118 1119 -1120 -1121 1122 -1123 -1124 1125 -1126 -1127 1128 -1129 1130
+v -1131 -1132 1133 -1134 -1135 1136 -1137 -1138 1139 -1140 1141 -1142 1143
+v -1144 -1145 1146 -1147 1148 -1149 -1150 1151 -1152 -1153 1154 -1155 1156
+v -1157 -1158 1159 -1160 -1161 1162 -1163 -1164 1165 -1166 1167 -1168 1169
+v -1170 -1171 1172 -1173 1174 -1175 -1176 1177 1178 -1179 -1180 1181 -1182
+v -1183 1184 -1185 1186 -1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
+v 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 0
diff --git a/hCaD_V2/test/cnf/prime25.sol b/hCaD_V2/test/cnf/prime25.sol
new file mode 100644
index 0000000..f9fb287
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime25.sol
@@ -0,0 +1,8 @@
+s SATISFIABLE
+v 1 -2 -3 4 5 -6 -7 8 -9 -10 -11 -12 -13 -14 15 16 -17 -18 -19 20 -21 22 23 -24
+v -25 -26 27 -28 -29 30 31 -32 -33 -34 -35 -36 -37 -38 -39 40 -41 -42 43 -44 45
+v -46 -47 -48 49 -50 -51 -52 53 -54 -55 56 -57 58 -59 -60 61 -62 63 -64 65 66
+v -67 -68 69 70 -71 -72 -73 -74 75 -76 -77 -78 79 -80 -81 82 -83 -84 -85 -86 87
+v -88 -89 90 -91 92 -93 -94 -95 -96 -97 98 -99 -100 101 -102 103 -104 105 -106
+v -107 108 -109 110 -111 -112 113 114 -115 -116 117 -118 -119 120 -121 122 -123
+v 124 125 126 127 128 129 130 131 0
diff --git a/hCaD_V2/test/cnf/prime289.sol b/hCaD_V2/test/cnf/prime289.sol
new file mode 100644
index 0000000..abe3fba
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime289.sol
@@ -0,0 +1,38 @@
+s SATISFIABLE
+v 1 -2 -3 -4 5 -6 -7 -8 9 -10 -11 -12 13 -14 -15 -16 17 18 -19 -20 -21 -22 -23
+v 24 25 -26 -27 -28 -29 -30 31 32 -33 -34 -35 36 -37 -38 -39 -40 -41 -42 43 -44
+v 45 -46 -47 48 -49 -50 -51 -52 53 -54 -55 56 -57 -58 59 -60 61 -62 -63 -64 -65
+v 66 -67 68 -69 -70 71 -72 73 74 -75 76 -77 -78 79 -80 -81 82 -83 -84 85 -86 87
+v -88 -89 90 -91 -92 93 -94 -95 96 -97 -98 -99 100 -101 -102 103 104 -105 -106
+v -107 -108 -109 -110 -111 -112 113 -114 -115 116 -117 118 -119 -120 -121 -122
+v -123 124 -125 -126 127 -128 129 -130 -131 -132 -133 -134 135 -136 -137 138
+v -139 140 -141 -142 -143 144 -145 -146 -147 148 -149 -150 151 -152 -153 -154
+v 155 -156 -157 158 -159 -160 161 -162 163 -164 -165 166 -167 -168 169 -170
+v -171 172 -173 174 -175 -176 177 -178 -179 180 -181 -182 183 -184 185 -186
+v -187 188 -189 -190 191 -192 -193 194 -195 196 -197 -198 -199 -200 201 -202
+v 203 -204 -205 206 -207 -208 -209 -210 211 -212 -213 214 -215 -216 217 -218
+v 219 -220 -221 222 -223 -224 225 -226 -227 228 -229 230 -231 -232 233 -234
+v -235 236 -237 -238 239 -240 241 -242 -243 244 -245 -246 247 -248 -249 250
+v -251 252 -253 -254 255 -256 -257 258 -259 -260 261 -262 263 -264 -265 -266
+v -267 268 -269 270 -271 -272 273 -274 -275 276 -277 -278 279 -280 281 -282
+v -283 284 -285 -286 287 -288 -289 290 -291 292 -293 -294 295 -296 -297 298
+v -299 -300 301 -302 303 -304 305 306 -307 -308 309 310 -311 -312 -313 -314 315
+v -316 317 -318 -319 320 -321 -322 323 -324 -325 326 -327 328 -329 -330 331
+v -332 -333 334 -335 -336 337 -338 -339 -340 341 -342 -343 344 -345 346 -347
+v -348 349 -350 -351 352 -353 354 -355 -356 357 -358 -359 360 -361 -362 363
+v -364 365 -366 -367 -368 -369 -370 371 -372 -373 374 -375 376 -377 -378 -379
+v -380 -381 382 -383 -384 385 -386 387 -388 -389 -390 -391 -392 393 -394 -395
+v 396 -397 398 -399 -400 -401 -402 -403 404 -405 -406 407 -408 409 -410 411
+v -412 -413 414 -415 416 -417 -418 419 -420 -421 422 -423 424 -425 -426 427
+v -428 -429 430 -431 -432 433 -434 435 -436 -437 438 -439 -440 441 -442 -443
+v 444 -445 446 -447 -448 449 -450 -451 452 -453 -454 455 -456 457 -458 -459 460
+v -461 -462 463 -464 -465 466 -467 468 -469 470 -471 -472 473 -474 475 -476
+v -477 478 -479 -480 481 -482 483 -484 -485 486 -487 -488 489 -490 -491 492
+v -493 494 -495 -496 497 -498 -499 500 -501 -502 503 -504 505 -506 -507 508
+v -509 -510 511 -512 -513 514 -515 516 -517 518 -519 -520 521 -522 523 -524
+v -525 526 -527 -528 529 -530 531 -532 -533 534 -535 -536 537 -538 -539 540
+v -541 542 -543 -544 545 -546 -547 548 -549 -550 551 -552 553 -554 555 -556
+v -557 558 -559 560 -561 -562 563 -564 -565 566 -567 568 -569 -570 571 -572
+v -573 574 -575 -576 577 -578 579 -580 581 -582 -583 584 -585 586 -587 -588 589
+v 590 -591 -592 593 -594 -595 596 -597 598 -599 600 601 602 603 604 605 606 607
+v 608 609 610 611 612 613 614 615 0
diff --git a/hCaD_V2/test/cnf/prime361.sol b/hCaD_V2/test/cnf/prime361.sol
new file mode 100644
index 0000000..10bf663
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime361.sol
@@ -0,0 +1,38 @@
+s SATISFIABLE
+v 1 2 -3 -4 5 -6 -7 -8 9 10 -11 -12 13 -14 -15 -16 17 18 -19 -20 -21 -22 -23 24
+v 25 -26 -27 -28 -29 -30 31 32 33 34 35 -36 -37 -38 -39 40 -41 -42 43 -44 45
+v -46 -47 48 -49 -50 -51 -52 -53 54 -55 -56 -57 58 -59 -60 -61 62 -63 -64 -65
+v 66 -67 -68 69 -70 -71 72 73 74 -75 76 -77 -78 79 -80 -81 82 -83 -84 85 -86
+v -87 -88 -89 90 -91 -92 93 -94 -95 96 -97 -98 -99 100 -101 -102 103 104 -105
+v -106 -107 -108 109 -110 -111 -112 113 114 -115 -116 -117 -118 119 -120 -121
+v -122 -123 124 -125 -126 127 -128 -129 130 -131 -132 -133 -134 135 -136 -137
+v 138 -139 -140 141 142 -143 -144 145 -146 -147 148 -149 -150 151 -152 -153
+v -154 -155 -156 -157 158 -159 -160 161 -162 163 -164 -165 -166 -167 -168 169
+v -170 -171 172 -173 174 -175 -176 -177 -178 -179 180 -181 -182 183 -184 185
+v -186 -187 -188 189 190 -191 -192 193 -194 -195 -196 197 -198 -199 -200 201
+v -202 -203 204 -205 -206 207 -208 -209 -210 211 -212 -213 214 -215 -216 217
+v -218 219 -220 -221 222 -223 -224 225 -226 -227 228 -229 230 -231 -232 233
+v -234 -235 236 -237 -238 239 -240 241 -242 -243 244 -245 -246 247 -248 -249
+v 250 -251 252 -253 -254 -255 -256 -257 258 -259 -260 261 -262 263 -264 -265
+v -266 -267 268 -269 270 -271 -272 273 -274 -275 276 -277 -278 279 -280 281
+v -282 -283 284 -285 -286 287 -288 -289 290 -291 292 -293 -294 295 -296 -297
+v 298 -299 -300 301 -302 303 -304 305 306 -307 -308 309 310 -311 -312 -313 -314
+v 315 -316 317 -318 -319 320 -321 -322 323 -324 -325 326 -327 328 -329 -330 331
+v -332 -333 334 -335 -336 337 -338 -339 -340 341 -342 -343 344 -345 346 -347
+v -348 349 -350 -351 352 -353 354 -355 -356 357 -358 -359 360 -361 -362 363
+v -364 365 -366 -367 -368 -369 -370 371 -372 -373 374 -375 376 -377 -378 -379
+v -380 -381 382 -383 -384 385 -386 387 -388 -389 -390 -391 -392 393 -394 -395
+v 396 -397 398 -399 -400 -401 -402 -403 404 -405 -406 407 -408 409 -410 411
+v -412 -413 414 -415 416 -417 -418 419 -420 -421 422 -423 424 -425 -426 427
+v -428 -429 430 -431 -432 433 -434 435 -436 -437 438 -439 -440 441 -442 -443
+v 444 -445 446 -447 -448 449 -450 -451 452 -453 -454 455 -456 457 -458 -459 460
+v -461 -462 463 -464 -465 466 -467 468 -469 470 -471 -472 473 -474 475 -476
+v -477 478 -479 -480 481 -482 483 -484 -485 486 -487 -488 489 -490 -491 492
+v -493 494 -495 -496 497 -498 -499 500 -501 -502 503 -504 505 -506 -507 508
+v -509 -510 511 -512 -513 514 -515 516 -517 518 -519 -520 521 -522 523 -524
+v -525 526 -527 -528 529 -530 531 -532 -533 534 -535 -536 537 -538 -539 540
+v -541 542 -543 -544 545 -546 -547 548 -549 -550 551 -552 553 -554 555 -556
+v -557 558 -559 560 -561 -562 563 -564 -565 566 -567 568 -569 -570 571 -572
+v -573 574 -575 -576 577 -578 579 -580 581 -582 -583 584 -585 586 -587 -588 589
+v 590 -591 -592 593 -594 -595 596 -597 598 -599 600 601 602 603 604 605 606 607
+v 608 609 610 611 612 613 614 615 0
diff --git a/hCaD_V2/test/cnf/prime4.sol b/hCaD_V2/test/cnf/prime4.sol
new file mode 100644
index 0000000..2a7a8d5
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime4.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 -2 3 -4 -5 -6 7 -8 -9 -10 -11 12 -13 14 -15 -16 17 18 19 20 0
diff --git a/hCaD_V2/test/cnf/prime49.sol b/hCaD_V2/test/cnf/prime49.sol
new file mode 100644
index 0000000..24f0853
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime49.sol
@@ -0,0 +1,13 @@
+s SATISFIABLE
+v 1 2 3 -4 -5 6 7 8 -9 -10 11 -12 -13 -14 15 -16 -17 -18 19 20 21 22 23 -24 -25
+v 26 27 28 -29 -30 31 -32 -33 34 35 -36 -37 -38 -39 40 -41 42 43 -44 -45 -46 47
+v -48 49 -50 51 -52 -53 54 -55 56 -57 -58 59 -60 -61 -62 -63 -64 65 -66 -67 -68
+v 69 -70 -71 -72 73 74 -75 76 -77 -78 -79 -80 81 -82 -83 84 -85 -86 -87 88 -89
+v -90 91 -92 -93 94 -95 96 -97 -98 99 -100 101 -102 -103 -104 105 106 -107 -108
+v 109 -110 -111 -112 113 -114 -115 -116 -117 118 -119 -120 121 -122 -123 124
+v -125 -126 -127 128 -129 -130 131 -132 133 -134 -135 136 -137 -138 139 -140
+v 141 -142 -143 -144 -145 -146 147 -148 -149 150 -151 152 -153 -154 -155 -156
+v -157 158 -159 -160 161 -162 163 -164 165 -166 -167 168 -169 170 -171 -172 173
+v -174 -175 176 -177 178 -179 -180 181 -182 -183 184 -185 -186 187 -188 189
+v -190 191 -192 -193 194 -195 196 -197 -198 199 200 -201 -202 203 -204 -205 206
+v -207 208 -209 210 211 212 213 214 215 216 217 218 219 0
diff --git a/hCaD_V2/test/cnf/prime529.sol b/hCaD_V2/test/cnf/prime529.sol
new file mode 100644
index 0000000..f1e8f7c
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime529.sol
@@ -0,0 +1,49 @@
+s SATISFIABLE
+v 1 2 3 -4 5 -6 -7 -8 -9 10 11 12 -13 14 -15 -16 -17 -18 19 20 21 -22 -23 -24
+v -25 -26 27 28 29 -30 -31 -32 -33 -34 35 36 37 38 39 -40 -41 42 43 44 -45 -46
+v 47 -48 -49 50 51 -52 -53 -54 -55 56 -57 58 59 -60 -61 -62 63 -64 65 -66 67
+v -68 -69 70 -71 72 -73 -74 75 -76 77 78 -79 -80 81 -82 -83 -84 85 -86 87 -88
+v -89 90 -91 92 -93 -94 -95 -96 97 -98 99 -100 -101 -102 -103 104 -105 106 -107
+v -108 -109 110 -111 -112 113 -114 115 -116 -117 -118 -119 120 -121 122 -123
+v -124 -125 126 -127 -128 -129 130 -131 -132 -133 134 -135 136 -137 -138 139
+v -140 -141 142 -143 -144 145 146 147 -148 -149 150 -151 -152 -153 154 -155
+v -156 -157 -158 -159 160 -161 -162 -163 164 -165 -166 -167 168 169 170 -171
+v -172 173 174 -175 -176 177 -178 -179 -180 -181 -182 -183 184 -185 -186 187
+v -188 189 -190 191 -192 -193 194 -195 -196 -197 198 -199 200 -201 -202 -203
+v -204 205 -206 207 -208 -209 210 -211 -212 -213 -214 215 -216 -217 218 -219
+v -220 221 -222 223 -224 -225 -226 -227 228 -229 -230 231 -232 -233 -234 235
+v -236 237 -238 -239 240 -241 -242 243 -244 -245 246 -247 -248 249 -250 -251
+v -252 253 -254 255 -256 -257 -258 259 -260 -261 262 -263 -264 265 -266 267
+v -268 -269 -270 -271 272 -273 274 -275 -276 277 -278 -279 -280 -281 282 -283
+v -284 285 -286 -287 288 -289 290 -291 -292 293 -294 -295 296 -297 -298 299
+v -300 301 -302 -303 -304 -305 -306 307 -308 -309 310 -311 312 -313 314 -315
+v 316 -317 -318 -319 -320 321 -322 323 -324 -325 326 -327 -328 329 -330 -331
+v 332 -333 334 -335 -336 337 -338 -339 340 -341 -342 343 -344 345 -346 -347
+v -348 -349 350 -351 352 -353 -354 355 -356 -357 358 -359 -360 361 -362 363
+v -364 -365 366 -367 -368 369 -370 -371 372 -373 374 -375 -376 377 -378 -379
+v 380 -381 -382 383 -384 385 -386 -387 -388 389 -390 -391 -392 393 -394 -395
+v -396 397 -398 399 -400 -401 402 -403 -404 405 -406 -407 408 -409 410 -411
+v -412 413 -414 -415 416 -417 -418 419 -420 421 -422 -423 424 -425 -426 427
+v -428 -429 430 -431 -432 -433 434 -435 -436 437 -438 439 -440 -441 442 -443
+v -444 445 -446 447 -448 -449 450 -451 -452 453 -454 -455 456 -457 458 -459
+v -460 461 -462 -463 464 -465 -466 467 -468 469 -470 -471 -472 -473 -474 475
+v -476 -477 478 -479 480 -481 -482 -483 -484 -485 486 -487 -488 489 -490 491
+v -492 -493 -494 -495 -496 497 -498 -499 500 -501 502 -503 -504 -505 -506 -507
+v 508 -509 -510 511 -512 513 -514 515 -516 -517 518 -519 520 -521 -522 523 -524
+v -525 526 -527 528 -529 -530 531 -532 -533 534 -535 -536 537 -538 539 -540
+v -541 542 -543 -544 545 -546 -547 548 -549 550 -551 -552 553 -554 -555 556
+v -557 -558 559 -560 561 -562 -563 564 -565 -566 567 -568 -569 570 -571 572
+v -573 -574 575 -576 -577 578 -579 -580 581 -582 583 -584 585 -586 -587 588
+v -589 590 -591 -592 593 -594 -595 596 -597 598 -599 -600 601 -602 -603 604
+v -605 -606 607 -608 609 -610 -611 612 -613 -614 615 -616 -617 618 -619 620
+v -621 -622 623 -624 -625 626 -627 -628 629 -630 631 -632 -633 634 -635 -636
+v 637 -638 -639 640 -641 642 -643 644 -645 -646 647 -648 649 -650 -651 652 -653
+v -654 655 -656 657 -658 -659 660 -661 -662 663 -664 -665 666 -667 668 -669
+v -670 671 -672 -673 674 -675 -676 677 -678 679 -680 -681 682 -683 -684 685
+v -686 -687 688 -689 690 -691 692 -693 -694 695 -696 697 -698 -699 700 -701
+v -702 703 -704 705 -706 -707 708 -709 -710 711 -712 -713 714 -715 716 -717
+v -718 719 -720 -721 722 -723 -724 725 -726 727 -728 729 -730 -731 732 -733 734
+v -735 -736 737 -738 -739 740 -741 742 -743 -744 745 -746 -747 748 -749 -750
+v 751 -752 753 -754 755 -756 -757 758 -759 760 -761 -762 763 764 -765 -766 767
+v -768 -769 770 -771 772 -773 774 775 776 777 778 779 780 781 782 783 784 785
+v 786 787 788 789 790 791 0
diff --git a/hCaD_V2/test/cnf/prime841.sol b/hCaD_V2/test/cnf/prime841.sol
new file mode 100644
index 0000000..9cfa7cf
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime841.sol
@@ -0,0 +1,49 @@
+s SATISFIABLE
+v 1 -2 3 4 5 -6 -7 -8 -9 10 -11 12 13 14 -15 -16 -17 -18 19 20 21 -22 -23 -24
+v -25 -26 27 28 29 -30 -31 -32 -33 -34 35 36 -37 -38 -39 40 -41 42 43 -44 -45
+v -46 47 -48 -49 50 51 -52 -53 54 55 -56 -57 -58 -59 60 -61 -62 63 -64 -65 66
+v -67 -68 69 -70 71 -72 -73 -74 -75 76 77 78 -79 -80 -81 -82 83 -84 -85 86 -87
+v -88 89 90 -91 92 -93 -94 -95 -96 97 -98 -99 100 -101 -102 -103 104 -105 -106
+v 107 108 -109 -110 -111 -112 -113 -114 -115 -116 117 -118 -119 120 -121 122
+v -123 124 -125 126 127 -128 -129 -130 131 -132 133 -134 135 -136 -137 -138 139
+v 140 -141 -142 -143 -144 145 -146 -147 148 -149 150 -151 -152 -153 154 -155
+v -156 -157 -158 159 -160 -161 162 -163 -164 165 -166 167 -168 169 -170 171
+v -172 -173 -174 -175 176 -177 178 -179 180 -181 -182 -183 184 185 -186 -187
+v -188 -189 190 191 -192 193 -194 -195 -196 -197 198 -199 -200 201 -202 -203
+v -204 205 -206 -207 208 -209 -210 211 -212 -213 -214 215 -216 -217 218 -219
+v -220 221 -222 223 -224 -225 -226 227 -228 -229 -230 231 -232 -233 -234 235
+v 236 -237 -238 -239 240 241 -242 -243 244 -245 -246 247 -248 249 250 -251 -252
+v -253 254 -255 256 -257 -258 -259 -260 -261 262 -263 -264 265 -266 267 -268
+v -269 -270 -271 272 -273 274 -275 -276 277 -278 -279 -280 -281 282 -283 -284
+v 285 -286 -287 288 -289 290 -291 -292 293 -294 -295 296 -297 -298 299 -300 301
+v -302 -303 -304 -305 306 -307 -308 309 -310 -311 -312 313 314 -315 316 -317
+v -318 -319 -320 321 -322 -323 324 -325 326 -327 -328 329 -330 -331 332 -333
+v -334 335 -336 337 -338 -339 340 -341 -342 343 -344 -345 346 -347 -348 -349
+v 350 -351 -352 353 -354 -355 356 -357 358 -359 -360 361 -362 363 -364 -365 366
+v -367 -368 369 -370 -371 372 -373 374 -375 -376 377 -378 -379 380 -381 -382
+v 383 -384 385 -386 -387 -388 389 390 -391 -392 393 -394 -395 -396 397 -398
+v -399 -400 -401 402 -403 -404 405 -406 -407 408 -409 -410 -411 -412 413 -414
+v -415 416 -417 -418 419 -420 -421 -422 -423 424 -425 -426 427 -428 -429 430
+v -431 -432 -433 434 -435 -436 437 -438 439 -440 -441 442 -443 -444 445 -446
+v 447 -448 -449 450 -451 -452 453 -454 -455 456 -457 458 -459 -460 461 -462
+v -463 464 -465 -466 467 -468 469 -470 -471 -472 -473 -474 475 -476 -477 478
+v -479 480 -481 -482 -483 -484 -485 486 -487 -488 489 -490 491 -492 -493 -494
+v -495 -496 497 -498 -499 500 -501 502 -503 -504 -505 -506 -507 508 -509 -510
+v 511 -512 513 -514 515 -516 -517 518 -519 520 -521 -522 523 -524 -525 526 -527
+v 528 -529 -530 531 -532 -533 534 -535 -536 537 -538 539 -540 -541 542 -543
+v -544 545 -546 -547 548 -549 550 -551 -552 553 -554 -555 556 -557 -558 559
+v -560 561 -562 -563 564 -565 -566 567 -568 -569 570 -571 572 -573 -574 575
+v -576 -577 578 -579 -580 581 -582 583 -584 585 -586 -587 588 -589 590 -591
+v -592 593 -594 -595 596 -597 598 -599 -600 601 -602 -603 604 -605 -606 607
+v -608 609 -610 -611 612 -613 -614 615 -616 -617 618 -619 620 -621 -622 623
+v -624 -625 626 -627 -628 629 -630 631 -632 -633 634 -635 -636 637 -638 -639
+v 640 -641 642 -643 644 -645 -646 647 -648 649 -650 -651 652 -653 -654 655 -656
+v 657 -658 -659 660 -661 -662 663 -664 -665 666 -667 668 -669 -670 671 -672
+v -673 674 -675 -676 677 -678 679 -680 -681 682 -683 -684 685 -686 -687 688
+v -689 690 -691 692 -693 -694 695 -696 697 -698 -699 700 -701 -702 703 -704 705
+v -706 -707 708 -709 -710 711 -712 -713 714 -715 716 -717 -718 719 -720 -721
+v 722 -723 -724 725 -726 727 -728 729 -730 -731 732 -733 734 -735 -736 737 -738
+v -739 740 -741 742 -743 -744 745 -746 -747 748 -749 -750 751 -752 753 -754 755
+v -756 -757 758 -759 760 -761 -762 763 764 -765 -766 767 -768 -769 770 -771 772
+v -773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
+v 0
diff --git a/hCaD_V2/test/cnf/prime9.sol b/hCaD_V2/test/cnf/prime9.sol
new file mode 100644
index 0000000..7ad9eb1
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime9.sol
@@ -0,0 +1,4 @@
+s SATISFIABLE
+v 1 -2 3 4 -5 6 -7 -8 -9 -10 11 12 13 14 15 -16 -17 -18 -19 20 -21 -22 23 -24
+v 25 -26 -27 28 -29 -30 -31 32 -33 -34 -35 -36 37 -38 -39 -40 41 -42 -43 44 -45
+v -46 -47 48 -49 50 -51 -52 53 -54 -55 56 -57 58 -59 60 61 62 63 64 65 0
diff --git a/hCaD_V2/test/cnf/prime961.sol b/hCaD_V2/test/cnf/prime961.sol
new file mode 100644
index 0000000..c5ace62
--- /dev/null
+++ b/hCaD_V2/test/cnf/prime961.sol
@@ -0,0 +1,48 @@
+s SATISFIABLE
+v 1 2 3 4 5 -6 -7 -8 -9 10 11 12 13 14 -15 -16 -17 -18 19 20 21 -22 -23 -24 -25
+v -26 27 28 29 -30 -31 -32 -33 -34 35 36 37 38 39 -40 -41 42 43 44 -45 -46 47
+v -48 -49 50 51 -52 -53 54 55 56 -57 58 59 -60 -61 -62 63 -64 -65 66 67 -68 -69
+v 70 -71 -72 73 74 -75 -76 77 78 79 -80 81 82 -83 -84 -85 86 -87 -88 89 90 -91
+v 92 93 -94 -95 -96 97 -98 -99 100 101 -102 -103 104 -105 -106 107 108 -109
+v -110 -111 -112 113 -114 115 116 -117 -118 -119 120 -121 122 -123 124 -125 126
+v 127 -128 -129 -130 131 -132 133 -134 135 -136 137 138 -139 -140 -141 142 -143
+v 144 -145 146 -147 -148 149 -150 151 -152 -153 154 -155 -156 -157 -158 -159
+v 160 -161 -162 -163 164 -165 -166 -167 168 169 -170 171 -172 -173 -174 -175
+v 176 -177 -178 179 180 -181 182 -183 -184 -185 -186 187 -188 -189 190 191 -192
+v 193 -194 -195 -196 -197 198 -199 -200 201 -202 -203 -204 205 -206 -207 208
+v -209 -210 211 -212 -213 -214 215 -216 -217 218 -219 -220 221 -222 223 -224
+v -225 -226 227 228 -229 -230 231 -232 -233 -234 235 236 -237 238 239 -240 -241
+v -242 243 -244 -245 246 247 -248 249 250 -251 -252 -253 254 -255 -256 257 -258
+v -259 -260 -261 262 -263 -264 265 -266 -267 268 -269 -270 -271 272 -273 -274
+v 275 -276 -277 278 -279 -280 -281 282 -283 -284 285 -286 -287 288 -289 290
+v -291 -292 293 -294 -295 296 -297 -298 299 -300 301 -302 -303 -304 305 306
+v -307 -308 309 -310 -311 -312 313 314 -315 316 317 -318 -319 -320 321 -322
+v -323 324 -325 -326 -327 -328 329 -330 -331 332 -333 -334 335 -336 -337 -338
+v -339 340 -341 -342 343 -344 -345 346 -347 -348 -349 350 -351 -352 353 -354
+v -355 356 -357 358 -359 -360 361 -362 363 -364 -365 366 -367 -368 369 -370
+v -371 372 -373 374 -375 -376 377 -378 -379 380 -381 -382 383 -384 385 -386
+v -387 -388 389 390 -391 -392 393 -394 -395 -396 397 -398 -399 -400 -401 402
+v -403 -404 405 -406 -407 408 -409 -410 -411 -412 413 -414 -415 416 -417 -418
+v 419 -420 -421 -422 -423 424 -425 -426 427 -428 -429 430 -431 -432 -433 434
+v -435 -436 437 -438 439 -440 -441 442 -443 -444 445 -446 447 -448 -449 450
+v -451 -452 453 -454 -455 456 -457 458 -459 -460 461 -462 -463 464 -465 -466
+v 467 -468 469 -470 -471 -472 -473 -474 475 -476 -477 478 -479 480 -481 -482
+v -483 -484 -485 486 -487 -488 489 -490 491 -492 -493 -494 -495 -496 497 -498
+v -499 500 -501 502 -503 -504 -505 -506 -507 508 -509 -510 511 -512 513 -514
+v 515 -516 -517 518 -519 520 -521 -522 523 -524 -525 526 -527 528 -529 -530 531
+v -532 -533 534 -535 -536 537 -538 539 -540 -541 542 -543 -544 545 -546 -547
+v 548 -549 550 -551 -552 553 -554 -555 556 -557 -558 559 -560 561 -562 -563 564
+v -565 -566 567 -568 -569 570 -571 572 -573 -574 575 -576 -577 578 -579 -580
+v 581 -582 583 -584 585 -586 -587 588 -589 590 -591 -592 593 -594 -595 596 -597
+v 598 -599 -600 601 -602 -603 604 -605 -606 607 -608 609 -610 -611 612 -613
+v -614 615 -616 -617 618 -619 620 -621 -622 623 -624 -625 626 -627 -628 629
+v -630 631 -632 -633 634 -635 -636 637 -638 -639 640 -641 642 -643 644 -645
+v -646 647 -648 649 -650 -651 652 -653 -654 655 -656 657 -658 -659 660 -661
+v -662 663 -664 -665 666 -667 668 -669 -670 671 -672 -673 674 -675 -676 677
+v -678 679 -680 -681 682 -683 -684 685 -686 -687 688 -689 690 -691 692 -693
+v -694 695 -696 697 -698 -699 700 -701 -702 703 -704 705 -706 -707 708 -709
+v -710 711 -712 -713 714 -715 716 -717 -718 719 -720 -721 722 -723 -724 725
+v -726 727 -728 729 -730 -731 732 -733 734 -735 -736 737 -738 -739 740 -741 742
+v -743 -744 745 -746 -747 748 -749 -750 751 -752 753 -754 755 -756 -757 758
+v -759 760 -761 -762 763 764 -765 -766 767 -768 -769 770 -771 772 -773 774 775
+v 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 0
diff --git a/hCaD_V2/test/cnf/regr000.sol b/hCaD_V2/test/cnf/regr000.sol
new file mode 100644
index 0000000..a793b84
--- /dev/null
+++ b/hCaD_V2/test/cnf/regr000.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 -2 -3 -4 -5 -6 -7 -8 -9 10 0
diff --git a/hCaD_V2/test/cnf/run.sh b/hCaD_V2/test/cnf/run.sh
new file mode 100644
index 0000000..f69e617
--- /dev/null
+++ b/hCaD_V2/test/cnf/run.sh
@@ -0,0 +1,314 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+die () {
+  cecho "${HIDE}test/cnf/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  exit 1
+}
+
+msg () {
+  cecho "${HIDE}test/cnf/run.sh:${NORMAL} $*"
+}
+
+for dir in . .. ../..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+[ -d ../test -a -d ../test/cnf ] || \
+die "needs to be called from a top-level sub-directory of CaDiCaL"
+
+[ x"$CADICALBUILD" = x ] && CADICALBUILD="../build"
+
+[ -x "$CADICALBUILD/cadical" ] || \
+  die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
+
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "CNF testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
+
+make -C $CADICALBUILD
+res=$?
+[ $res = 0 ] || exit $res
+
+#--------------------------------------------------------------------------#
+
+coresolver="$CADICALBUILD/cadical"
+simpsolver="$CADICALBUILD/../scripts/run-simplifier-and-extend-solution.sh"
+proofchecker=$CADICALBUILD/drat-trim
+solutionchecker=$CADICALBUILD/precochk
+makefile=$CADICALBUILD/makefile
+
+if [ ! -f $proofchecker -o ! -f $solutionchecker ]
+then
+
+  if [ ! -f $solutionchecker -o ../test/cnf/precochk.c -nt $solutionchecker ]
+  then
+    cmd="cc -O -o $solutionchecker ../test/cnf/precochk.c -lz"
+    cecho "$cmd"
+    if $cmd 2>/dev/null
+    then
+      msg "external solution checking with '$solutionchecker'"
+    else
+      msg "no external solution checking " \
+          "(compiling '../test/cnf/preochk.c' failed)"
+      solutionchecker=none
+    fi
+  fi
+
+  if [ ! -f $proofchecker -o ../test/cnf/drat-trim.c -nt $proofchecker ]
+  then
+    cmd="cc -O -o $proofchecker ../test/cnf/drat-trim.c"
+    if $cmd 2>/dev/null
+    then
+      msg "external proof checking with '$proofchecker'"
+    else
+      msg "no external proof checking " \
+          "(compiling '../test/cnf/drat-trim.c' failed)"
+      proofchecker=none
+    fi
+  fi
+else
+  msg "external solution checking with '$solutionchecker'"
+  msg "external proof checking with '$proofchecker'"
+fi
+
+
+#--------------------------------------------------------------------------#
+
+ok=0
+failed=0
+
+core () {
+  msg "running CNF test core ${HILITE}'$1'${NORMAL}"
+  prefix=$CADICALBUILD/test-cnf-core
+  cnf=../test/cnf/$1.cnf
+  prf=$prefix-$1.prf
+  log=$prefix-$1.log
+  err=$prefix-$1.err
+  chk=$prefix-$1.chk
+  if [ -f cnf/$1.sol ]
+  then
+    solopts=" -r ../test/cnf/$1.sol"
+  else
+    solopts=""
+  fi
+  if [ ! $2 = 20 -o x"$proofchecker" = xnone ]
+  then
+    proofopts=""
+  else
+    proofopts=" $prf"
+  fi
+  opts="$cnf --check$solopts$proofopts"
+  cecho "$coresolver \\"
+  cecho "$opts"
+  cecho -n "# $2 ..."
+  "$coresolver" $opts 1>$log 2>$err
+  res=$?
+  if [ ! $res = $2 ] 
+  then
+    cecho " ${BAD}FAILED${NORMAL} (actual exit code $res)"
+    failed=`expr $failed + 1`
+  elif [ $res = 10 ]
+  then
+    if [ "$solopts" = "" ]
+    then
+      cecho " ${GOOD}ok${NORMAL} (without solution file)"
+    else
+      cecho " ${GOOD}ok${NORMAL} (solution file checked after parsing)"
+    fi
+    if [ x"$solutionchecker" = xnone ]
+    then
+	ok=`expr $ok + 1`
+    else
+      cecho "$solutionchecker \\"
+      cecho "$cnf $log"
+      cecho -n "# 0 ..."
+      if $solutionchecker $cnf $log 1>&2 >$chk
+      then
+        cecho " ${GOOD}ok${NORMAL} (solution checked externally too)"
+	ok=`expr $ok + 1`
+      else
+	cecho " ${BAD}FAILED${NORMAL} (incorrect solution)"
+	failed=`expr $failed + 1`
+      fi
+    fi
+  elif [ $res = 20 ]
+  then
+    cecho " ${GOOD}ok${NORMAL} (exit code as expected)"
+    if [ ! x"$proofchecker" = xnone ]
+    then
+      cecho "$proofchecker \\"
+      cecho "$cnf $prf"
+      cecho -n "# 0 ..."
+      if $proofchecker $cnf $prf 1>&2 >$chk
+      then
+	cecho " ${GOOD}ok${NORMAL} (proof checked)"
+	ok=`expr $ok + 1`
+      else
+	cecho " ${BAD}FAILED${NORMAL} (proof check '$proofchecker $cnf $prf' failed)"
+	failed=`expr $failed + 1`
+      fi
+    fi
+  else 
+    cecho " ${BAD}FAILED${NORMAL} (unsupported exit code $res)"
+    failed=`expr $failed + 1`
+  fi
+}
+
+simp () {
+  msg "running CNF test simp ${HILITE}'$1'${NORMAL}"
+  prefix=$CADICALBUILD/test-cnf-simp
+  cnf=../test/cnf/$1.cnf
+  log=$prefix-$1.log
+  err=$prefix-$1.err
+  chk=$prefix-$1.chk
+  opts="$cnf"
+  cecho "$simpsolver \\"
+  cecho "$opts"
+  cecho -n "# $2 ..."
+  "$simpsolver" $opts 1>$log 2>$err
+  res=$?
+  if [ ! $res = $2 ] 
+  then
+    cecho " ${BAD}FAILED${NORMAL} (actual exit code $res)"
+    failed=`expr $failed + 1`
+  elif [ $res = 10 ]
+  then
+    cecho " ${GOOD}ok${NORMAL}"
+    if [ x"$solutionchecker" = xnone ]
+    then
+	ok=`expr $ok + 1`
+    else
+      cecho "$solutionchecker \\"
+      cecho "$cnf $log"
+      cecho -n "# 0 ..."
+      if $solutionchecker $cnf $log 1>&2 >$chk
+      then
+        cecho " ${GOOD}ok${NORMAL} (solution checked externally)"
+	ok=`expr $ok + 1`
+      else
+	cecho " ${BAD}FAILED${NORMAL} (incorrect solution)"
+	failed=`expr $failed + 1`
+      fi
+    fi
+  fi
+}
+
+run () {
+  core $*
+  simp $*
+}
+
+run empty 10
+run false 20
+
+run unit0 10
+run unit1 10
+run unit2 10
+run unit3 10
+run unit4 20
+run unit5 20
+run unit6 20
+run unit7 20
+
+run sub0 10
+
+run sat0 20
+run sat1 10
+run sat2 10
+run sat3 10
+run sat4 10
+run sat5 20
+run sat6 10
+run sat7 10
+run sat8 10
+run sat9 10
+run sat10 10
+run sat11 10
+run sat12 10
+run sat13 10
+
+run full1 20
+run full2 20
+run full3 20
+run full4 20
+run full5 20
+run full6 20
+run full7 20
+
+run regr000 10
+run elimclash 20
+run elimredundant 10
+
+run block0 10
+
+run prime4 10
+run prime9 10
+run prime25 10
+run prime49 10
+run prime121 10
+run prime169 10
+run prime361 10
+run prime289 10
+run prime529 10
+run prime841 10
+run prime961 10
+run prime1369 10
+run prime1681 10
+run prime1849 10
+run prime2209 10
+
+run factor2708413neg 10
+run factor2708413pos 10
+
+run sqrt2809 10
+run sqrt3481 10
+run sqrt3721 10
+run sqrt4489 10
+run sqrt5041 10
+run sqrt5329 10
+run sqrt6241 10
+run sqrt6889 10
+run sqrt7921 10
+run sqrt9409 10
+run sqrt10201 10
+run sqrt10609 10
+run sqrt11449 10
+run sqrt11881 10
+run sqrt12769 10
+run sqrt16129 10
+run sqrt63001 10
+run sqrt259081 10
+run sqrt1042441 10
+
+run ph2 20
+run ph3 20
+run ph4 20
+run ph5 20
+run ph6 20
+
+run add4 20
+run add8 20
+run add16 20
+run add32 20
+run add64 20
+run add128 20
+
+run prime65537 20
+
+#--------------------------------------------------------------------------#
+
+[ $ok -gt 0 ] && OK="$GOOD"
+[ $failed -gt 0 ] && FAILED="$BAD"
+
+msg "${HILITE}CNF testing results:${NORMAL} ${OK}$ok ok${NORMAL}, ${FAILED}$failed failed${NORMAL}"
+
+exit $failed
diff --git a/hCaD_V2/test/cnf/sat1.sol b/hCaD_V2/test/cnf/sat1.sol
new file mode 100644
index 0000000..4904b64
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat1.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 2 0
diff --git a/hCaD_V2/test/cnf/sat10.sol b/hCaD_V2/test/cnf/sat10.sol
new file mode 100644
index 0000000..cf21d8c
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat10.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 2 3 0
diff --git a/hCaD_V2/test/cnf/sat11.sol b/hCaD_V2/test/cnf/sat11.sol
new file mode 100644
index 0000000..0e6dc62
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat11.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 2 -3 0
diff --git a/hCaD_V2/test/cnf/sat12.sol b/hCaD_V2/test/cnf/sat12.sol
new file mode 100644
index 0000000..280ec06
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat12.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 -2 3 0
diff --git a/hCaD_V2/test/cnf/sat13.sol b/hCaD_V2/test/cnf/sat13.sol
new file mode 100644
index 0000000..dab4908
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat13.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 -2 -3 0
diff --git a/hCaD_V2/test/cnf/sat2.sol b/hCaD_V2/test/cnf/sat2.sol
new file mode 100644
index 0000000..9aa456a
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat2.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 -2 0
diff --git a/hCaD_V2/test/cnf/sat3.sol b/hCaD_V2/test/cnf/sat3.sol
new file mode 100644
index 0000000..543c85e
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat3.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 2 0
diff --git a/hCaD_V2/test/cnf/sat4.sol b/hCaD_V2/test/cnf/sat4.sol
new file mode 100644
index 0000000..8aafa17
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat4.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 -2 0
diff --git a/hCaD_V2/test/cnf/sat6.sol b/hCaD_V2/test/cnf/sat6.sol
new file mode 100644
index 0000000..272b0bc
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat6.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 2 3 0
diff --git a/hCaD_V2/test/cnf/sat7.sol b/hCaD_V2/test/cnf/sat7.sol
new file mode 100644
index 0000000..c542e1d
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat7.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 2 -3 0
diff --git a/hCaD_V2/test/cnf/sat8.sol b/hCaD_V2/test/cnf/sat8.sol
new file mode 100644
index 0000000..65863b6
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat8.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 -2 3 0
diff --git a/hCaD_V2/test/cnf/sat9.sol b/hCaD_V2/test/cnf/sat9.sol
new file mode 100644
index 0000000..c94ff9a
--- /dev/null
+++ b/hCaD_V2/test/cnf/sat9.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 -2 -3 0
diff --git a/hCaD_V2/test/cnf/sqrt10201.sol b/hCaD_V2/test/cnf/sqrt10201.sol
new file mode 100644
index 0000000..5386d08
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt10201.sol
@@ -0,0 +1,19 @@
+s SATISFIABLE
+v 1 2 -3 -4 -5 6 7 8 -9 -10 -11 12 -13 -14 15 16 -17 -18 -19 -20 21 -22 23 -24
+v -25 26 -27 -28 29 -30 -31 -32 33 -34 -35 36 -37 -38 39 40 -41 42 -43 -44 45
+v -46 -47 -48 49 -50 -51 52 -53 -54 55 -56 -57 58 -59 -60 61 62 -63 64 -65 66
+v 67 -68 -69 70 -71 -72 73 -74 -75 76 -77 -78 79 -80 -81 82 -83 -84 85 -86 -87
+v 88 -89 -90 91 92 -93 -94 95 -96 97 -98 99 100 101 -102 -103 104 -105 -106
+v 107 -108 -109 110 -111 -112 113 -114 -115 116 -117 -118 119 -120 -121 122
+v -123 -124 125 -126 -127 128 129 -130 -131 -132 -133 134 -135 -136 137 138
+v -139 140 141 142 -143 144 -145 -146 -147 148 -149 -150 151 -152 -153 154
+v -155 -156 157 -158 -159 160 -161 -162 163 164 -165 -166 -167 -168 169 -170
+v -171 172 -173 -174 175 176 177 -178 -179 180 181 182 -183 -184 185 -186 -187
+v 188 -189 -190 191 -192 -193 194 -195 -196 197 -198 -199 200 -201 -202 203
+v 204 -205 -206 -207 -208 209 -210 -211 212 213 -214 -215 -216 217 218 219
+v -220 221 -222 -223 224 -225 -226 227 -228 -229 230 -231 -232 233 -234 -235
+v -236 237 -238 -239 240 -241 -242 243 244 -245 246 247 248 -249 250 -251 -252
+v 253 -254 -255 -256 257 -258 -259 260 -261 -262 263 -264 -265 266 267 268 269
+v 270 -271 -272 273 -274 -275 276 277 -278 -279 -280 281 -282 -283 284 -285
+v -286 287 288 -289 -290 -291 292 293 294 295 296 297 298 299 300 301 302 303
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt1042441.sol b/hCaD_V2/test/cnf/sqrt1042441.sol
new file mode 100644
index 0000000..ce082fc
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt1042441.sol
@@ -0,0 +1,42 @@
+s SATISFIABLE
+v 1 2 -3 4 5 6 7 8 9 10 11 -12 -13 -14 15 -16 -17 18 19 -20 -21 22 -23 24 -25
+v -26 27 -28 -29 30 -31 -32 33 34 -35 -36 -37 -38 39 40 -41 -42 43 -44 -45 46
+v -47 -48 49 50 -51 -52 -53 -54 55 -56 -57 58 -59 -60 61 62 -63 -64 65 -66 67
+v 68 -69 70 -71 -72 73 -74 -75 76 77 -78 -79 -80 -81 82 83 -84 -85 -86 87 -88
+v -89 90 -91 -92 -93 94 95 -96 -97 98 -99 100 101 -102 -103 104 -105 -106 107
+v -108 -109 110 111 -112 -113 -114 -115 116 117 -118 -119 -120 -121 122 123
+v -124 -125 -126 127 -128 -129 130 -131 -132 -133 134 135 -136 -137 138 -139
+v 140 141 -142 143 -144 -145 146 -147 -148 149 -150 -151 152 153 -154 -155
+v -156 -157 158 159 -160 -161 -162 -163 164 165 -166 -167 -168 -169 170 171
+v -172 -173 -174 175 -176 -177 178 -179 -180 -181 182 183 -184 -185 186 -187
+v 188 189 -190 191 -192 -193 -194 195 -196 -197 198 -199 -200 201 202 -203
+v -204 -205 -206 207 208 -209 -210 -211 -212 213 214 -215 -216 -217 -218 219
+v 220 -221 -222 -223 -224 225 226 -227 -228 -229 230 -231 -232 233 -234 -235
+v -236 237 238 -239 -240 241 -242 243 244 -245 246 -247 248 -249 -250 -251 252
+v -253 -254 255 -256 -257 258 259 -260 -261 -262 -263 264 265 -266 -267 -268
+v -269 270 271 -272 -273 -274 -275 276 277 -278 -279 -280 -281 282 283 -284
+v -285 -286 -287 288 289 -290 -291 -292 293 -294 -295 296 -297 -298 -299 300
+v 301 -302 -303 -304 305 306 -307 308 -309 310 -311 -312 -313 -314 315 -316
+v 317 -318 -319 -320 321 322 -323 -324 -325 -326 327 328 -329 -330 -331 -332
+v 333 334 -335 -336 -337 -338 339 340 -341 -342 -343 -344 345 346 -347 -348
+v -349 -350 351 352 -353 -354 -355 -356 357 -358 -359 360 -361 -362 363 364
+v -365 -366 -367 368 369 370 -371 372 -373 374 -375 -376 -377 -378 -379 -380
+v 381 382 -383 -384 -385 -386 387 388 -389 -390 -391 -392 393 394 -395 -396
+v -397 -398 399 400 -401 -402 -403 -404 405 406 -407 -408 -409 -410 411 412
+v -413 -414 -415 -416 417 -418 -419 420 421 -422 -423 -424 -425 426 -427 428
+v 429 430 -431 432 -433 -434 -435 -436 -437 438 -439 -440 -441 -442 443 444
+v -445 -446 -447 -448 449 450 -451 -452 -453 -454 455 456 -457 -458 -459 -460
+v 461 462 -463 -464 -465 -466 467 468 -469 -470 -471 472 -473 -474 -475 476
+v 477 -478 -479 -480 481 -482 483 -484 485 -486 -487 -488 -489 490 -491 -492
+v -493 -494 495 496 -497 -498 -499 -500 501 502 -503 -504 -505 -506 507 508
+v -509 -510 -511 -512 513 514 -515 -516 -517 -518 519 520 -521 -522 -523 -524
+v 525 -526 527 -528 529 -530 -531 -532 -533 534 -535 -536 -537 -538 539 540
+v -541 -542 -543 -544 545 546 -547 -548 -549 -550 551 552 -553 -554 -555 -556
+v 557 558 -559 -560 -561 -562 563 -564 565 -566 567 -568 -569 -570 571 -572
+v -573 -574 -575 576 577 -578 -579 -580 -581 582 583 -584 -585 -586 -587 588
+v 589 -590 -591 -592 -593 594 -595 596 -597 -598 -599 600 -601 -602 -603 -604
+v 605 606 -607 -608 -609 -610 611 612 -613 -614 -615 -616 617 -618 619 -620
+v -621 622 -623 -624 -625 -626 627 628 -629 -630 -631 -632 633 -634 635 -636
+v -637 -638 -639 -640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
+v 655 656 657 658 659
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt10609.sol b/hCaD_V2/test/cnf/sqrt10609.sol
new file mode 100644
index 0000000..73d5757
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt10609.sol
@@ -0,0 +1,20 @@
+s SATISFIABLE
+v 1 2 3 -4 -5 6 7 8 9 10 -11 -12 -13 -14 15 16 -17 -18 -19 20 -21 -22 -23 24
+v 25 -26 -27 -28 -29 30 31 -32 -33 -34 35 -36 -37 -38 -39 -40 -41 42 -43 -44
+v -45 46 47 -48 -49 -50 -51 52 -53 -54 55 -56 -57 58 -59 -60 61 62 -63 64 -65
+v -66 67 -68 -69 70 -71 -72 73 -74 -75 76 77 -78 -79 -80 81 -82 -83 84 -85 -86
+v 87 -88 -89 90 -91 -92 -93 94 95 96 97 -98 99 -100 101 102 -103 -104 -105 106
+v -107 -108 109 -110 -111 -112 113 -114 -115 116 -117 -118 119 -120 -121 122
+v -123 -124 125 126 -127 -128 -129 130 -131 -132 -133 134 135 -136 137 138
+v -139 140 141 -142 143 -144 -145 -146 -147 148 -149 -150 151 -152 -153 154
+v -155 -156 157 -158 -159 160 -161 -162 163 164 -165 -166 -167 -168 169 170
+v -171 -172 -173 174 -175 -176 177 -178 -179 180 181 182 183 -184 -185 -186
+v 187 -188 -189 190 -191 -192 193 -194 -195 196 -197 -198 199 -200 -201 202
+v -203 -204 -205 206 207 -208 -209 -210 -211 212 -213 -214 215 -216 217 218
+v -219 -220 -221 222 -223 -224 225 -226 -227 228 -229 -230 231 -232 -233 234
+v -235 -236 237 -238 -239 240 241 -242 -243 -244 -245 246 247 248 -249 250
+v -251 -252 253 -254 -255 -256 257 -258 -259 260 -261 -262 263 264 -265 -266
+v -267 268 269 270 -271 -272 273 -274 -275 276 277 -278 -279 -280 -281 282
+v -283 284 -285 -286 287 288 -289 -290 -291 292 293 294 295 296 297 298 299
+v 300 301 302 303
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt11449.sol b/hCaD_V2/test/cnf/sqrt11449.sol
new file mode 100644
index 0000000..d8c7c7e
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt11449.sol
@@ -0,0 +1,20 @@
+s SATISFIABLE
+v 1 -2 3 4 -5 6 7 -8 9 -10 -11 12 13 -14 -15 -16 17 -18 19 -20 -21 -22 -23 24
+v 25 -26 -27 -28 29 -30 -31 32 -33 -34 -35 36 -37 38 39 -40 -41 -42 43 44 -45
+v -46 -47 48 -49 -50 51 -52 -53 -54 55 -56 -57 58 -59 -60 61 62 -63 64 -65 66
+v -67 -68 -69 70 71 -72 -73 -74 75 -76 -77 78 -79 -80 81 -82 -83 84 -85 -86 87
+v -88 -89 90 -91 -92 -93 94 95 96 97 -98 99 100 -101 102 -103 -104 -105 -106
+v 107 -108 -109 110 -111 -112 113 114 -115 -116 -117 118 -119 -120 121 -122
+v -123 124 -125 -126 -127 128 -129 -130 131 132 -133 -134 135 136 -137 138
+v -139 -140 141 -142 143 -144 -145 -146 147 -148 -149 150 -151 -152 153 -154
+v -155 -156 157 -158 -159 160 -161 -162 163 -164 -165 166 -167 -168 169 170
+v -171 -172 -173 -174 175 -176 -177 178 179 180 181 182 -183 -184 185 -186
+v -187 188 189 -190 -191 -192 193 -194 -195 196 -197 -198 199 -200 -201 -202
+v 203 -204 -205 206 -207 -208 209 210 -211 -212 -213 214 215 -216 217 -218 219
+v -220 -221 222 223 -224 -225 -226 227 -228 -229 230 -231 -232 233 -234 -235
+v 236 -237 -238 -239 240 241 -242 -243 -244 -245 246 247 -248 -249 -250 251
+v -252 -253 254 255 -256 -257 -258 259 -260 -261 262 -263 -264 -265 266 267
+v 268 -269 270 -271 -272 273 274 -275 -276 -277 -278 279 -280 -281 282 283
+v -284 285 -286 -287 -288 289 -290 -291 292 293 294 295 296 297 298 299 300
+v 301 302 303
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt11881.sol b/hCaD_V2/test/cnf/sqrt11881.sol
new file mode 100644
index 0000000..804b0f7
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt11881.sol
@@ -0,0 +1,20 @@
+s SATISFIABLE
+v 1 2 -3 4 -5 6 7 8 -9 -10 -11 12 -13 -14 15 16 -17 -18 19 -20 21 -22 -23 24
+v -25 -26 27 -28 -29 30 31 -32 -33 -34 -35 36 -37 -38 -39 40 -41 42 -43 -44 45
+v -46 -47 -48 49 50 -51 -52 -53 54 -55 -56 57 -58 -59 60 -61 62 -63 64 65 -66
+v 67 -68 -69 70 -71 -72 73 74 -75 -76 -77 -78 79 80 -81 -82 -83 84 -85 -86 87
+v -88 -89 90 -91 -92 -93 94 95 -96 97 -98 -99 -100 101 -102 -103 104 -105 -106
+v 107 -108 -109 110 111 -112 -113 -114 -115 116 117 -118 -119 -120 121 -122
+v -123 124 -125 -126 127 -128 -129 130 -131 -132 -133 134 -135 136 137 138
+v -139 -140 -141 142 -143 144 -145 -146 -147 148 149 -150 -151 -152 153 -154
+v -155 -156 157 -158 -159 160 -161 -162 163 164 -165 -166 -167 168 -169 -170
+v 171 -172 -173 174 -175 176 177 -178 179 180 181 -182 -183 -184 185 186 -187
+v -188 -189 -190 191 -192 -193 194 -195 -196 197 -198 -199 200 201 -202 -203
+v -204 -205 206 207 -208 -209 -210 211 -212 -213 214 -215 -216 217 218 -219
+v 220 -221 -222 -223 224 -225 -226 227 -228 -229 230 -231 -232 233 -234 -235
+v -236 237 238 -239 -240 -241 -242 243 -244 -245 246 247 -248 -249 -250 251
+v -252 -253 254 255 -256 -257 -258 259 -260 -261 262 -263 -264 -265 266 267
+v 268 -269 270 -271 -272 273 274 -275 -276 -277 -278 279 -280 -281 282 283
+v -284 285 -286 -287 -288 289 -290 -291 292 293 294 295 296 297 298 299 300
+v 301 302 303
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt12769.sol b/hCaD_V2/test/cnf/sqrt12769.sol
new file mode 100644
index 0000000..233f78c
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt12769.sol
@@ -0,0 +1,19 @@
+s SATISFIABLE
+v 1 -2 -3 -4 5 6 7 -8 -9 -10 11 -12 -13 14 -15 -16 17 -18 -19 -20 21 -22 23
+v -24 -25 26 -27 -28 29 -30 -31 32 -33 -34 35 -36 37 -38 39 40 -41 -42 43 -44
+v -45 46 -47 -48 49 -50 -51 52 -53 -54 55 -56 -57 58 59 -60 -61 62 -63 64 -65
+v 66 67 -68 -69 70 -71 -72 73 -74 -75 76 -77 -78 79 -80 -81 82 -83 -84 85 -86
+v -87 88 89 -90 -91 -92 -93 94 95 -96 -97 -98 99 100 101 -102 -103 104 -105
+v -106 107 -108 -109 110 -111 -112 113 -114 -115 116 -117 -118 119 -120 -121
+v 122 123 -124 -125 -126 127 -128 -129 130 -131 -132 -133 134 -135 136 -137
+v -138 -139 140 141 142 -143 144 -145 -146 147 -148 -149 150 -151 -152 153
+v -154 -155 156 -157 -158 159 -160 -161 -162 163 -164 -165 166 -167 -168 169
+v -170 -171 172 -173 -174 175 176 -177 178 -179 180 181 182 -183 184 -185 -186
+v 187 -188 -189 190 -191 -192 193 -194 -195 -196 197 -198 -199 200 -201 -202
+v 203 -204 -205 206 -207 -208 209 -210 -211 212 213 -214 215 216 217 218 219
+v -220 221 -222 -223 224 -225 -226 -227 228 -229 -230 231 232 -233 -234 -235
+v 236 -237 -238 239 -240 -241 242 -243 244 245 -246 247 248 -249 -250 251 -252
+v -253 254 255 -256 -257 -258 -259 260 261 -262 -263 -264 265 -266 -267 268
+v -269 270 -271 -272 273 274 -275 -276 -277 -278 279 280 -281 -282 -283 284
+v -285 -286 -287 -288 -289 290 291 292 293 294 295 296 297 298 299 300 301 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt16129.sol b/hCaD_V2/test/cnf/sqrt16129.sol
new file mode 100644
index 0000000..edf19dc
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt16129.sol
@@ -0,0 +1,20 @@
+s SATISFIABLE
+v 1 2 3 4 5 6 7 8 9 10 -11 -12 -13 -14 15 16 -17 -18 19 20 -21 22 -23 -24 -25
+v -26 27 28 -29 -30 -31 -32 33 34 -35 -36 37 38 -39 -40 41 -42 -43 -44 -45 46
+v 47 -48 -49 -50 -51 52 53 -54 -55 -56 -57 58 59 -60 -61 62 63 -64 65 -66 -67
+v 68 -69 -70 -71 -72 73 74 -75 -76 -77 -78 79 80 -81 -82 -83 -84 85 86 -87 -88
+v -89 -90 91 92 -93 -94 95 96 -97 98 -99 -100 -101 102 -103 -104 -105 -106 107
+v 108 -109 -110 -111 -112 113 114 -115 -116 -117 -118 119 120 -121 -122 -123
+v -124 125 126 -127 -128 -129 -130 131 132 -133 -134 135 -136 137 -138 139
+v -140 -141 -142 143 -144 -145 -146 -147 148 149 -150 -151 -152 -153 154 155
+v -156 -157 -158 -159 160 161 -162 -163 -164 -165 166 167 -168 -169 -170 -171
+v 172 173 -174 -175 -176 177 -178 179 -180 -181 -182 183 -184 -185 -186 -187
+v 188 189 -190 -191 -192 -193 194 195 -196 -197 -198 -199 200 201 -202 -203
+v -204 -205 206 207 -208 -209 -210 -211 212 -213 214 -215 216 -217 -218 -219
+v 220 -221 -222 -223 -224 225 226 -227 -228 -229 -230 231 232 -233 -234 -235
+v -236 237 238 -239 -240 -241 -242 243 -244 245 -246 -247 -248 249 -250 -251
+v -252 -253 254 255 -256 -257 -258 -259 260 261 -262 -263 -264 -265 266 -267
+v 268 -269 -270 271 -272 -273 -274 -275 276 277 -278 -279 -280 -281 282 -283
+v 284 -285 -286 -287 -288 -289 290 291 292 293 294 295 296 297 298 299 300 301
+v 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt259081.sol b/hCaD_V2/test/cnf/sqrt259081.sol
new file mode 100644
index 0000000..9a5b008
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt259081.sol
@@ -0,0 +1,33 @@
+s SATISFIABLE
+v 1 2 -3 4 5 6 7 8 9 10 -11 -12 -13 14 -15 -16 17 18 -19 -20 21 -22 23 -24 -25
+v 26 -27 -28 29 -30 -31 32 33 -34 -35 -36 -37 38 39 -40 -41 42 -43 -44 45 -46
+v -47 48 49 -50 -51 -52 -53 54 -55 -56 57 -58 -59 60 61 -62 -63 64 -65 66 67
+v -68 69 -70 -71 72 -73 -74 75 76 -77 -78 -79 -80 81 82 -83 -84 -85 86 -87 -88
+v 89 -90 -91 -92 93 94 -95 -96 97 -98 99 100 -101 -102 103 -104 -105 106 -107
+v -108 109 110 -111 -112 -113 -114 115 116 -117 -118 -119 -120 121 122 -123
+v -124 -125 126 -127 -128 129 -130 -131 -132 133 134 -135 -136 137 -138 139
+v 140 -141 142 -143 -144 145 -146 -147 148 -149 -150 151 152 -153 -154 -155
+v -156 157 158 -159 -160 -161 -162 163 164 -165 -166 -167 -168 169 170 -171
+v -172 -173 174 -175 -176 177 -178 -179 -180 181 182 -183 -184 185 -186 187
+v 188 -189 190 -191 -192 -193 194 -195 -196 197 -198 -199 200 201 -202 -203
+v -204 -205 206 207 -208 -209 -210 -211 212 213 -214 -215 -216 -217 218 219
+v -220 -221 -222 -223 224 225 -226 -227 -228 229 -230 -231 232 -233 -234 -235
+v 236 237 -238 -239 -240 241 242 -243 244 -245 246 -247 -248 -249 250 -251 252
+v -253 -254 -255 256 257 -258 -259 -260 -261 262 263 -264 -265 -266 -267 268
+v 269 -270 -271 -272 -273 274 275 -276 -277 -278 -279 280 281 -282 -283 -284
+v -285 286 -287 -288 289 -290 -291 292 293 -294 -295 -296 297 298 299 -300 301
+v -302 -303 -304 -305 -306 -307 308 309 -310 -311 -312 -313 314 315 -316 -317
+v -318 -319 320 321 -322 -323 -324 -325 326 327 -328 -329 -330 -331 332 333
+v -334 -335 -336 -337 338 -339 -340 341 342 -343 -344 -345 -346 347 -348 349
+v 350 351 -352 353 -354 -355 -356 -357 358 -359 -360 -361 -362 363 364 -365
+v -366 -367 -368 369 370 -371 -372 -373 -374 375 376 -377 -378 -379 -380 381
+v 382 -383 -384 -385 386 -387 -388 -389 390 391 -392 -393 -394 395 -396 397
+v -398 -399 -400 -401 402 -403 -404 -405 -406 407 408 -409 -410 -411 -412 413
+v 414 -415 -416 -417 -418 419 420 -421 -422 -423 -424 425 426 -427 -428 -429
+v -430 431 -432 433 -434 435 -436 -437 -438 439 -440 -441 -442 -443 444 445
+v -446 -447 -448 -449 450 451 -452 -453 -454 -455 456 457 -458 -459 -460 -461
+v 462 -463 464 -465 -466 -467 468 -469 -470 -471 -472 473 474 -475 -476 -477
+v -478 479 480 -481 -482 -483 -484 485 -486 487 -488 -489 490 -491 -492 -493
+v -494 495 496 -497 -498 -499 -500 501 -502 503 -504 -505 -506 -507 -508 509
+v 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt2809.sol b/hCaD_V2/test/cnf/sqrt2809.sol
new file mode 100644
index 0000000..2fbbe3d
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt2809.sol
@@ -0,0 +1,14 @@
+s SATISFIABLE
+v 1 2 -3 -4 5 6 7 -8 -9 -10 11 -12 -13 14 15 -16 -17 -18 -19 20 -21 22 -23 -24
+v 25 -26 -27 28 -29 -30 -31 32 -33 -34 35 36 -37 38 39 -40 -41 42 -43 -44 45
+v 46 -47 -48 -49 50 -51 -52 53 -54 -55 56 -57 -58 -59 60 61 -62 63 -64 -65 66
+v -67 -68 69 -70 -71 72 -73 -74 75 76 -77 -78 -79 80 -81 -82 83 -84 -85 86 -87
+v -88 89 -90 -91 -92 93 -94 95 96 97 -98 99 -100 101 -102 -103 -104 105 106
+v -107 -108 -109 110 -111 -112 113 -114 -115 -116 117 -118 -119 120 -121 -122
+v 123 -124 -125 126 127 128 129 -130 131 -132 -133 -134 135 136 -137 -138 -139
+v 140 -141 -142 143 -144 -145 146 -147 -148 149 -150 -151 -152 153 -154 -155
+v 156 157 -158 159 160 -161 -162 -163 164 -165 -166 167 168 -169 -170 -171 172
+v -173 -174 175 -176 -177 178 -179 180 181 -182 183 -184 -185 186 187 -188
+v -189 -190 -191 192 -193 -194 195 196 -197 198 -199 -200 -201 202 -203 -204
+v 205 206 207 208 209 210 211 212 213 214
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt3481.sol b/hCaD_V2/test/cnf/sqrt3481.sol
new file mode 100644
index 0000000..5a8e321
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt3481.sol
@@ -0,0 +1,14 @@
+s SATISFIABLE
+v 1 -2 3 4 5 6 -7 8 -9 -10 11 12 -13 -14 -15 16 -17 18 -19 -20 -21 -22 23 24
+v -25 -26 -27 28 -29 -30 31 -32 -33 -34 35 36 37 38 -39 40 -41 -42 -43 -44 45
+v -46 -47 48 -49 -50 51 52 -53 -54 -55 56 -57 -58 -59 60 61 62 -63 -64 65 -66
+v 67 -68 -69 -70 -71 72 -73 -74 75 -76 -77 78 -79 -80 81 82 -83 -84 -85 -86 87
+v -88 -89 90 91 -92 -93 94 95 -96 -97 98 -99 100 -101 -102 -103 104 -105 -106
+v 107 -108 -109 -110 111 112 -113 -114 -115 116 -117 -118 119 -120 -121 -122
+v 123 124 -125 -126 -127 -128 129 130 -131 132 -133 -134 135 -136 -137 138 139
+v -140 -141 -142 -143 144 145 -146 -147 -148 149 -150 -151 152 -153 -154 -155
+v 156 157 158 -159 -160 161 -162 -163 164 165 -166 -167 -168 -169 170 171 -172
+v -173 -174 -175 176 -177 -178 179 180 181 -182 -183 184 -185 -186 -187 -188
+v 189 190 -191 -192 -193 194 -195 -196 197 -198 -199 -200 -201 -202 203 204
+v 205 206 207 208 209 210 211 212 213
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt3721.sol b/hCaD_V2/test/cnf/sqrt3721.sol
new file mode 100644
index 0000000..21b4adf
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt3721.sol
@@ -0,0 +1,14 @@
+s SATISFIABLE
+v 1 2 -3 4 5 6 7 -8 -9 -10 11 -12 -13 14 15 -16 -17 18 -19 20 -21 -22 23 -24
+v -25 26 -27 -28 29 30 -31 -32 -33 -34 35 36 -37 -38 39 -40 -41 42 -43 -44 45
+v 46 -47 -48 -49 -50 51 -52 -53 54 -55 -56 57 58 -59 -60 61 -62 63 64 -65 66
+v -67 -68 69 -70 -71 72 73 -74 -75 -76 -77 78 79 -80 -81 -82 83 -84 -85 86 -87
+v -88 -89 90 91 -92 -93 -94 95 96 -97 -98 99 -100 101 -102 -103 -104 105 106
+v -107 -108 -109 -110 111 112 -113 -114 -115 -116 117 -118 -119 120 -121 -122
+v 123 124 -125 -126 -127 128 129 130 -131 -132 -133 -134 135 136 -137 -138
+v -139 -140 141 142 -143 -144 -145 -146 147 -148 -149 150 151 -152 -153 -154
+v -155 156 -157 158 159 -160 -161 162 -163 -164 -165 -166 167 168 -169 -170
+v -171 172 -173 -174 -175 176 177 -178 -179 -180 181 -182 -183 184 -185 -186
+v -187 -188 189 190 -191 -192 -193 -194 195 -196 197 -198 -199 -200 -201 -202
+v 203 204 205 206 207 208 209 210 211 212 213
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt4489.sol b/hCaD_V2/test/cnf/sqrt4489.sol
new file mode 100644
index 0000000..7da087b
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt4489.sol
@@ -0,0 +1,19 @@
+s SATISFIABLE
+v 1 -2 3 -4 -5 -6 7 -8 9 -10 -11 12 13 -14 -15 -16 17 -18 -19 -20 -21 -22 23
+v -24 -25 -26 27 -28 -29 30 -31 -32 33 -34 -35 36 -37 -38 39 40 -41 42 -43 -44
+v 45 -46 -47 48 -49 -50 51 -52 -53 54 -55 -56 57 -58 -59 60 -61 -62 -63 64 -65
+v 66 67 -68 69 -70 -71 72 -73 -74 75 -76 -77 78 -79 -80 81 -82 -83 84 -85 -86
+v 87 -88 -89 90 -91 -92 93 -94 95 -96 97 -98 99 100 101 -102 -103 104 -105
+v -106 107 -108 -109 110 -111 -112 113 -114 -115 116 -117 -118 119 -120 -121
+v 122 -123 -124 125 -126 -127 128 -129 -130 131 132 -133 -134 135 136 -137 138
+v -139 140 141 142 -143 -144 145 -146 -147 148 -149 -150 151 -152 -153 154
+v -155 -156 157 -158 -159 160 -161 -162 163 -164 -165 166 -167 -168 169 170
+v -171 -172 -173 -174 175 -176 -177 178 -179 180 181 182 -183 184 -185 -186
+v 187 -188 -189 190 -191 -192 193 -194 -195 196 -197 -198 199 -200 -201 202
+v -203 -204 205 -206 -207 208 -209 -210 -211 212 213 -214 215 -216 217 218 219
+v -220 221 -222 -223 224 -225 -226 227 -228 -229 230 -231 -232 233 -234 -235
+v 236 -237 -238 239 -240 -241 242 -243 244 -245 246 247 248 -249 250 -251 -252
+v 253 -254 -255 256 -257 -258 259 -260 -261 262 -263 -264 265 -266 267 -268
+v 269 270 -271 272 -273 -274 275 -276 -277 278 -279 -280 281 -282 283 284 -285
+v -286 287 -288 -289 290 291 292 293 294 295 296 297 298 299 300 301 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt5041.sol b/hCaD_V2/test/cnf/sqrt5041.sol
new file mode 100644
index 0000000..b704991
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt5041.sol
@@ -0,0 +1,19 @@
+s SATISFIABLE
+v 1 2 3 -4 -5 -6 7 8 9 10 -11 -12 -13 -14 15 16 -17 -18 -19 20 -21 -22 -23 24
+v 25 -26 -27 -28 -29 30 31 -32 -33 -34 35 -36 -37 -38 -39 -40 -41 42 -43 -44
+v -45 46 47 -48 -49 -50 -51 52 -53 -54 55 -56 -57 58 -59 -60 61 -62 -63 64 -65
+v -66 67 -68 69 -70 -71 72 -73 -74 75 -76 -77 -78 79 -80 -81 82 -83 -84 85 -86
+v -87 88 -89 -90 91 -92 -93 94 95 -96 97 -98 99 100 101 -102 -103 104 -105
+v -106 107 -108 -109 110 -111 -112 113 -114 -115 116 -117 -118 119 -120 -121
+v 122 -123 -124 125 -126 -127 128 -129 -130 131 132 -133 -134 135 136 -137 138
+v -139 140 141 142 -143 -144 145 -146 -147 148 -149 -150 151 -152 -153 154
+v -155 -156 157 -158 -159 160 -161 -162 163 -164 -165 166 -167 -168 169 170
+v -171 -172 -173 -174 175 -176 177 178 -179 180 181 182 -183 -184 185 -186
+v -187 188 -189 -190 191 -192 -193 194 -195 -196 197 -198 -199 200 -201 -202
+v 203 -204 -205 206 207 -208 -209 -210 -211 212 -213 -214 215 -216 217 218 219
+v -220 221 -222 -223 224 -225 -226 227 -228 -229 230 -231 -232 233 -234 -235
+v 236 -237 -238 239 -240 -241 -242 243 244 -245 246 247 248 -249 250 -251 -252
+v 253 -254 -255 256 -257 -258 259 -260 -261 262 -263 -264 265 -266 267 -268
+v 269 270 -271 272 -273 -274 275 -276 -277 278 -279 -280 281 -282 283 284 -285
+v -286 287 -288 -289 290 291 292 293 294 295 296 297 298 299 300 301 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt5329.sol b/hCaD_V2/test/cnf/sqrt5329.sol
new file mode 100644
index 0000000..77abcf7
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt5329.sol
@@ -0,0 +1,19 @@
+s SATISFIABLE
+v 1 -2 -3 4 -5 -6 7 -8 -9 -10 11 -12 -13 14 -15 -16 17 -18 19 -20 21 -22 -23
+v 24 -25 -26 27 -28 -29 30 -31 -32 33 34 -35 -36 -37 -38 39 40 -41 42 -43 -44
+v 45 -46 -47 48 -49 -50 51 -52 -53 54 -55 -56 -57 58 -59 -60 61 -62 -63 64 -65
+v 66 67 -68 69 -70 -71 72 -73 -74 75 -76 -77 78 -79 -80 81 -82 -83 84 -85 -86
+v 87 -88 -89 90 -91 -92 93 -94 95 -96 97 -98 99 100 101 -102 -103 104 -105
+v -106 107 -108 -109 110 -111 -112 113 114 -115 -116 -117 118 -119 -120 121
+v -122 -123 124 -125 -126 127 -128 -129 130 -131 -132 -133 134 -135 136 -137
+v 138 -139 -140 141 142 -143 144 -145 -146 147 -148 -149 150 -151 -152 153
+v -154 -155 -156 157 -158 -159 160 -161 -162 163 -164 -165 166 -167 -168 169
+v -170 -171 172 -173 -174 175 176 -177 178 -179 180 181 182 -183 184 -185 -186
+v 187 -188 -189 190 -191 -192 193 -194 -195 196 -197 -198 199 -200 -201 202
+v -203 -204 205 -206 -207 208 -209 -210 211 -212 213 214 215 -216 217 218 219
+v -220 -221 222 -223 -224 225 -226 -227 228 -229 -230 231 -232 -233 234 -235
+v -236 237 238 -239 -240 -241 242 -243 -244 -245 246 247 248 -249 250 -251
+v -252 253 -254 -255 256 -257 -258 259 -260 -261 262 -263 -264 -265 266 267
+v -268 269 270 -271 272 -273 -274 275 -276 -277 278 -279 -280 281 -282 283 284
+v -285 -286 287 -288 -289 290 291 292 293 294 295 296 297 298 299 300 301 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt6241.sol b/hCaD_V2/test/cnf/sqrt6241.sol
new file mode 100644
index 0000000..8bb2c7c
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt6241.sol
@@ -0,0 +1,20 @@
+s SATISFIABLE
+v 1 2 3 4 -5 -6 7 8 9 10 -11 -12 -13 -14 15 16 -17 -18 19 20 -21 22 -23 -24
+v -25 -26 27 28 -29 -30 -31 -32 33 34 -35 -36 -37 38 -39 -40 -41 -42 43 44 -45
+v -46 -47 -48 49 50 -51 -52 -53 -54 55 56 -57 -58 -59 60 -61 -62 -63 -64 65
+v -66 -67 -68 69 -70 -71 -72 73 74 -75 -76 -77 -78 79 80 -81 -82 -83 -84 85
+v -86 -87 88 -89 -90 91 -92 -93 94 95 -96 97 -98 -99 -100 101 -102 -103 104
+v -105 -106 107 -108 -109 110 111 -112 -113 -114 -115 116 117 -118 -119 -120
+v 121 -122 -123 124 -125 -126 127 -128 -129 130 -131 -132 -133 134 135 136
+v -137 138 -139 -140 -141 142 -143 -144 145 -146 -147 148 149 -150 -151 -152
+v 153 -154 -155 -156 157 -158 -159 160 -161 -162 163 -164 -165 166 -167 -168
+v 169 170 -171 -172 -173 174 -175 -176 177 178 -179 180 181 -182 -183 -184 185
+v 186 -187 -188 -189 190 -191 -192 193 -194 -195 196 -197 -198 199 -200 -201
+v 202 -203 -204 205 -206 -207 -208 209 210 -211 -212 -213 214 215 -216 217 218
+v -219 220 -221 -222 -223 224 -225 -226 227 -228 -229 230 -231 -232 233 -234
+v -235 236 -237 -238 -239 240 241 -242 -243 -244 -245 246 247 -248 -249 -250
+v 251 -252 -253 254 -255 -256 257 -258 -259 260 -261 -262 263 264 -265 -266
+v -267 -268 269 270 -271 272 -273 -274 275 -276 -277 278 -279 -280 -281 282
+v 283 284 -285 -286 287 -288 -289 290 291 292 293 294 295 296 297 298 299 300
+v 301 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt63001.sol b/hCaD_V2/test/cnf/sqrt63001.sol
new file mode 100644
index 0000000..3983987
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt63001.sol
@@ -0,0 +1,26 @@
+s SATISFIABLE
+v 1 -2 3 4 5 6 7 8 -9 10 -11 -12 13 14 -15 -16 -17 18 -19 20 -21 -22 -23 -24
+v 25 26 -27 -28 -29 30 -31 -32 33 -34 -35 -36 37 38 39 40 -41 42 -43 -44 -45
+v -46 47 -48 -49 50 -51 -52 53 54 -55 -56 -57 58 -59 -60 -61 62 63 64 -65 -66
+v 67 -68 69 -70 -71 -72 -73 74 -75 -76 77 -78 -79 80 -81 -82 83 84 -85 -86 -87
+v -88 89 -90 -91 92 93 -94 -95 96 97 98 -99 -100 101 -102 103 -104 -105 -106
+v -107 108 -109 -110 111 -112 -113 114 115 -116 -117 -118 -119 120 -121 -122
+v 123 -124 -125 126 127 -128 -129 -130 -131 132 133 -134 -135 136 137 -138
+v -139 140 141 -142 143 -144 145 -146 -147 -148 -149 150 -151 -152 153 -154
+v -155 156 157 -158 -159 -160 -161 162 163 -164 -165 -166 167 -168 -169 170
+v -171 -172 -173 174 175 -176 -177 -178 -179 180 181 -182 -183 184 -185 -186
+v 187 188 -189 -190 191 -192 193 -194 -195 -196 197 -198 -199 200 -201 -202
+v -203 204 205 -206 -207 -208 -209 210 211 -212 -213 -214 -215 216 -217 -218
+v 219 -220 -221 222 223 -224 -225 -226 -227 228 229 -230 -231 -232 -233 -234
+v 235 236 237 -238 -239 240 -241 -242 243 -244 -245 246 247 -248 -249 -250
+v -251 252 253 -254 -255 -256 -257 258 259 -260 -261 -262 263 -264 -265 -266
+v 267 268 -269 -270 -271 272 -273 -274 -275 276 277 278 -279 280 -281 -282
+v -283 284 -285 -286 287 288 -289 -290 -291 -292 293 294 -295 -296 -297 -298
+v 299 300 -301 -302 -303 -304 305 306 -307 -308 -309 -310 311 -312 -313 314
+v 315 316 -317 318 -319 -320 -321 322 -323 -324 -325 -326 327 328 -329 -330
+v -331 -332 333 334 -335 -336 -337 -338 339 340 -341 -342 -343 344 -345 -346
+v 347 -348 -349 -350 351 -352 -353 -354 -355 356 357 -358 -359 -360 -361 362
+v 363 -364 -365 -366 -367 368 -369 370 -371 -372 373 -374 -375 -376 -377 378
+v 379 -380 -381 -382 -383 384 -385 386 -387 -388 -389 -390 -391 392 393 394
+v 395 396 397 398 399 400 401 402 403 404 405 406
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt6889.sol b/hCaD_V2/test/cnf/sqrt6889.sol
new file mode 100644
index 0000000..2544373
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt6889.sol
@@ -0,0 +1,20 @@
+s SATISFIABLE
+v 1 -2 3 -4 5 -6 7 -8 9 -10 -11 12 13 -14 -15 -16 17 -18 -19 -20 -21 -22 23
+v -24 -25 -26 27 -28 -29 30 -31 -32 33 -34 -35 36 37 -38 39 40 -41 -42 43 -44
+v -45 46 -47 -48 49 -50 -51 52 -53 -54 55 -56 -57 58 59 -60 -61 -62 63 64 -65
+v 66 67 -68 -69 70 -71 -72 73 -74 -75 76 -77 -78 79 -80 -81 82 -83 -84 85 86
+v -87 -88 -89 -90 91 -92 -93 94 95 -96 -97 -98 99 100 101 -102 -103 104 -105
+v -106 107 -108 -109 110 -111 -112 113 -114 -115 116 -117 -118 119 -120 -121
+v 122 123 -124 -125 -126 127 -128 -129 130 -131 -132 -133 134 135 136 -137
+v -138 -139 140 141 142 -143 -144 145 -146 -147 148 -149 -150 151 -152 -153
+v 154 -155 -156 157 -158 -159 160 161 -162 -163 -164 165 -166 -167 168 -169
+v -170 -171 172 -173 -174 175 176 -177 178 -179 -180 181 182 -183 184 -185
+v -186 187 -188 -189 190 -191 -192 193 -194 -195 -196 197 198 -199 -200 -201
+v 202 -203 -204 205 -206 -207 208 -209 -210 211 -212 213 -214 215 -216 -217
+v 218 219 -220 221 -222 -223 224 -225 -226 227 -228 -229 -230 231 -232 -233
+v 234 -235 -236 237 -238 -239 240 -241 -242 243 244 245 246 247 248 -249 -250
+v 251 -252 -253 254 -255 -256 257 -258 -259 260 261 -262 -263 -264 265 -266
+v -267 -268 269 270 -271 272 -273 -274 275 -276 -277 278 -279 -280 -281 282
+v 283 284 -285 -286 287 -288 -289 290 291 292 293 294 295 296 297 298 299 300
+v 301 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt7921.sol b/hCaD_V2/test/cnf/sqrt7921.sol
new file mode 100644
index 0000000..3acceaa
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt7921.sol
@@ -0,0 +1,19 @@
+s SATISFIABLE
+v 1 -2 -3 4 5 -6 7 -8 -9 -10 11 -12 -13 14 -15 -16 17 -18 19 -20 21 -22 -23 24
+v -25 -26 27 -28 -29 30 -31 -32 33 34 -35 -36 37 -38 39 40 -41 -42 43 -44 -45
+v 46 -47 -48 49 -50 -51 52 -53 -54 55 56 -57 -58 -59 -60 61 -62 -63 -64 -65 66
+v 67 -68 69 -70 -71 72 -73 -74 75 -76 -77 78 -79 -80 81 -82 -83 -84 85 -86 -87
+v 88 -89 -90 91 -92 -93 94 95 -96 97 -98 99 100 101 -102 -103 104 -105 -106
+v 107 -108 -109 110 -111 -112 113 114 -115 -116 -117 118 -119 -120 121 -122
+v -123 124 -125 -126 127 -128 -129 130 -131 -132 -133 134 -135 136 -137 138
+v 139 -140 141 142 -143 144 -145 -146 147 -148 -149 150 -151 -152 -153 154 155
+v -156 -157 -158 -159 160 -161 -162 163 -164 -165 166 -167 -168 169 -170 -171
+v 172 -173 -174 175 176 -177 178 -179 180 -181 182 -183 184 -185 -186 187 -188
+v -189 190 -191 -192 -193 194 195 -196 -197 -198 199 -200 -201 202 -203 -204
+v 205 -206 -207 208 -209 -210 211 -212 213 214 215 -216 -217 218 219 -220 -221
+v 222 -223 -224 225 -226 -227 228 229 -230 -231 -232 233 -234 -235 236 -237
+v -238 -239 240 -241 -242 243 244 245 246 -247 248 -249 -250 251 252 -253 -254
+v -255 256 -257 -258 259 -260 -261 -262 263 -264 -265 266 267 -268 269 -270
+v -271 -272 273 -274 -275 276 -277 -278 279 -280 -281 282 283 284 -285 -286
+v 287 -288 -289 290 291 292 293 294 295 296 297 298 299 300 301 302
+v 0
diff --git a/hCaD_V2/test/cnf/sqrt9409.sol b/hCaD_V2/test/cnf/sqrt9409.sol
new file mode 100644
index 0000000..4250adb
--- /dev/null
+++ b/hCaD_V2/test/cnf/sqrt9409.sol
@@ -0,0 +1,19 @@
+s SATISFIABLE
+v 1 -2 -3 -4 -5 6 7 -8 -9 -10 11 -12 -13 14 -15 -16 17 -18 -19 -20 21 -22 23
+v -24 -25 26 -27 -28 29 -30 -31 32 -33 -34 35 -36 -37 -38 39 40 -41 42 -43 -44
+v 45 -46 -47 48 -49 -50 51 -52 -53 54 -55 -56 57 -58 -59 60 -61 62 -63 64 -65
+v 66 67 -68 -69 70 -71 -72 73 -74 -75 76 -77 -78 79 -80 -81 82 -83 -84 85 -86
+v -87 88 -89 -90 91 92 -93 -94 95 -96 97 -98 99 100 101 -102 -103 104 -105
+v -106 107 -108 -109 110 -111 -112 113 -114 -115 116 -117 -118 119 -120 -121
+v 122 -123 -124 125 -126 -127 128 129 -130 -131 -132 -133 134 -135 -136 -137
+v 138 -139 140 141 142 -143 144 -145 -146 147 -148 -149 150 -151 -152 153 -154
+v -155 156 -157 -158 159 -160 -161 162 -163 -164 165 -166 -167 -168 169 -170
+v -171 172 -173 -174 175 176 -177 178 -179 180 181 182 -183 184 -185 -186 187
+v -188 -189 190 -191 -192 193 -194 -195 196 -197 -198 199 -200 -201 202 -203
+v -204 205 -206 -207 208 -209 -210 211 -212 213 -214 215 -216 217 218 219 -220
+v 221 -222 -223 224 -225 -226 227 -228 -229 230 -231 -232 233 -234 -235 236
+v -237 -238 239 -240 -241 242 -243 244 -245 246 247 248 -249 250 -251 -252 253
+v -254 -255 -256 257 -258 -259 260 -261 -262 263 -264 -265 266 267 268 269 270
+v -271 -272 273 -274 -275 276 277 -278 -279 -280 281 -282 -283 284 -285 -286
+v 287 288 -289 -290 -291 292 293 294 295 296 297 298 299 300 301 302 303
+v 0
diff --git a/hCaD_V2/test/cnf/unit0.sol b/hCaD_V2/test/cnf/unit0.sol
new file mode 100644
index 0000000..697c38f
--- /dev/null
+++ b/hCaD_V2/test/cnf/unit0.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 0
diff --git a/hCaD_V2/test/cnf/unit1.sol b/hCaD_V2/test/cnf/unit1.sol
new file mode 100644
index 0000000..ca75ebf
--- /dev/null
+++ b/hCaD_V2/test/cnf/unit1.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 0
diff --git a/hCaD_V2/test/cnf/unit2.sol b/hCaD_V2/test/cnf/unit2.sol
new file mode 100644
index 0000000..4904b64
--- /dev/null
+++ b/hCaD_V2/test/cnf/unit2.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v 1 2 0
diff --git a/hCaD_V2/test/cnf/unit3.sol b/hCaD_V2/test/cnf/unit3.sol
new file mode 100644
index 0000000..8aafa17
--- /dev/null
+++ b/hCaD_V2/test/cnf/unit3.sol
@@ -0,0 +1,2 @@
+s SATISFIABLE
+v -1 -2 0
diff --git a/hCaD_V2/test/icnf/empty.icnf b/hCaD_V2/test/icnf/empty.icnf
new file mode 100644
index 0000000..a2c9f08
--- /dev/null
+++ b/hCaD_V2/test/icnf/empty.icnf
@@ -0,0 +1 @@
+p inccnf
diff --git a/hCaD_V2/test/icnf/false.icnf b/hCaD_V2/test/icnf/false.icnf
new file mode 100644
index 0000000..d3fb377
--- /dev/null
+++ b/hCaD_V2/test/icnf/false.icnf
@@ -0,0 +1,2 @@
+p inccnf
+0
diff --git a/hCaD_V2/test/icnf/makefile b/hCaD_V2/test/icnf/makefile
new file mode 100644
index 0000000..683eaf1
--- /dev/null
+++ b/hCaD_V2/test/icnf/makefile
@@ -0,0 +1,3 @@
+# execute ICNF tests with a single 'make' command in '../../build'
+test:
+	$(MAKE) -C .. cnf
diff --git a/hCaD_V2/test/icnf/run.sh b/hCaD_V2/test/icnf/run.sh
new file mode 100644
index 0000000..082ef20
--- /dev/null
+++ b/hCaD_V2/test/icnf/run.sh
@@ -0,0 +1,87 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+die () {
+  cecho "${HIDE}test/icnf/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  exit 1
+}
+
+msg () {
+  cecho "${HIDE}test/icnf/run.sh:${NORMAL} $*"
+}
+
+for dir in . .. ../..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+[ -d ../test -a -d ../test/icnf ] || \
+die "needs to be called from a top-level sub-directory of CaDiCaL"
+
+[ x"$CADICALBUILD" = x ] && CADICALBUILD="../build"
+
+[ -x "$CADICALBUILD/cadical" ] || \
+  die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
+
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "ICNF testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
+
+make -C $CADICALBUILD
+res=$?
+[ $res = 0 ] || exit $res
+
+#--------------------------------------------------------------------------#
+
+solver="$CADICALBUILD/cadical"
+
+#--------------------------------------------------------------------------#
+
+ok=0
+failed=0
+
+run () {
+  msg "running ICNF tests ${HILITE}'$1'${NORMAL}"
+  prefix=$CADICALBUILD/test-icnf
+  icnf=../test/icnf/$1.icnf
+  log=$prefix-$1.log
+  err=$prefix-$1.err
+  opts="$icnf --check"
+  opts="$icnf"
+  cecho "$solver \\"
+  cecho "$opts"
+  cecho -n "# $2 ..."
+  "$solver" $opts 1>$log 2>$err
+  res=$?
+  if [ ! $res = $2 ] 
+  then
+    cecho " ${BAD}FAILED${NORMAL} (actual exit code $res)"
+    failed=`expr $failed + 1`
+  else
+    cecho " ${GOOD}ok${NORMAL} (exit code '$res' as expected)"
+    ok=`expr $ok + 1`
+  fi
+}
+
+run empty 10
+run false 20
+run unit1 20
+run unit2 10
+run two1 20
+run two2 10
+
+#--------------------------------------------------------------------------#
+
+[ $ok -gt 0 ] && OK="$GOOD"
+[ $failed -gt 0 ] && FAILED="$BAD"
+
+msg "${HILITE}ICNF testing results:${NORMAL} ${OK}$ok ok${NORMAL}, ${FAILED}$failed failed${NORMAL}"
+
+exit $failed
diff --git a/hCaD_V2/test/icnf/two1.icnf b/hCaD_V2/test/icnf/two1.icnf
new file mode 100644
index 0000000..e45ae58
--- /dev/null
+++ b/hCaD_V2/test/icnf/two1.icnf
@@ -0,0 +1,7 @@
+p inccnf
+1 2 3 0
+-1 -2 3 0
+1 2 -3 0
+-1 -2 -3 0
+a 1 2 0
+a -1 -2 0
diff --git a/hCaD_V2/test/icnf/two2.icnf b/hCaD_V2/test/icnf/two2.icnf
new file mode 100644
index 0000000..c03414c
--- /dev/null
+++ b/hCaD_V2/test/icnf/two2.icnf
@@ -0,0 +1,7 @@
+p inccnf
+1 2 3 0
+-1 -2 3 0
+1 2 -3 0
+-1 -2 -3 0
+a 1 2 0
+a -1 2 0
diff --git a/hCaD_V2/test/icnf/unit1.icnf b/hCaD_V2/test/icnf/unit1.icnf
new file mode 100644
index 0000000..df8ff92
--- /dev/null
+++ b/hCaD_V2/test/icnf/unit1.icnf
@@ -0,0 +1,3 @@
+p inccnf
+1 0
+a -1 0
diff --git a/hCaD_V2/test/icnf/unit2.icnf b/hCaD_V2/test/icnf/unit2.icnf
new file mode 100644
index 0000000..3d550bd
--- /dev/null
+++ b/hCaD_V2/test/icnf/unit2.icnf
@@ -0,0 +1,3 @@
+p inccnf
+1 0
+a 1 0
diff --git a/hCaD_V2/test/makefile b/hCaD_V2/test/makefile
new file mode 100644
index 0000000..1c46862
--- /dev/null
+++ b/hCaD_V2/test/makefile
@@ -0,0 +1,14 @@
+test: usage trace api cnf icnf mbt
+api:
+	@api/run.sh
+cnf:
+	@cnf/run.sh
+icnf:
+	@icnf/run.sh
+mbt:
+	@mbt/run.sh
+trace:
+	@trace/run.sh
+usage:
+	@usage/run.sh
+.PHONY: test api cnf icnf mbt trace usage
diff --git a/hCaD_V2/test/mbt/README.md b/hCaD_V2/test/mbt/README.md
new file mode 100644
index 0000000..673bdd0
--- /dev/null
+++ b/hCaD_V2/test/mbt/README.md
@@ -0,0 +1,7 @@
+The model based tester binary `mobical` from the build directory is used to
+generate a certain number of random API calls.  Generated original and
+reduced error traces will go to the build directory.
+
+The `run.sh` script is only used for `make test`.
+
+The `makefile` allows to run this tests with a single `make`.
diff --git a/hCaD_V2/test/mbt/makefile b/hCaD_V2/test/mbt/makefile
new file mode 100644
index 0000000..ccbb0f1
--- /dev/null
+++ b/hCaD_V2/test/mbt/makefile
@@ -0,0 +1,3 @@
+# run a fixed number of the model based testing rounds with a single 'make'
+test:
+	$(MAKE) -C .. mbt
diff --git a/hCaD_V2/test/mbt/run.sh b/hCaD_V2/test/mbt/run.sh
new file mode 100644
index 0000000..33354c5
--- /dev/null
+++ b/hCaD_V2/test/mbt/run.sh
@@ -0,0 +1,63 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+die () {
+  cecho "${HIDE}test/mbt/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  exit 1
+}
+
+msg () {
+  cecho "${HIDE}test/mbt/run.sh:${NORMAL} $*"
+}
+
+for dir in . .. ../..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+[ -d ../test -a -d ../test/mbt ] || \
+die "needs to be called from a top-level sub-directory of CaDiCaL"
+
+[ x"$CADICALBUILD" = x ] && CADICALBUILD="../build"
+
+[ -x "$CADICALBUILD/cadical" ] || \
+  die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
+
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "Model-Based Testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
+
+make -C $CADICALBUILD
+res=$?
+[ $res = 0 ] || exit $res
+
+#--------------------------------------------------------------------------#
+
+tests=1000
+
+msg "generating and running $tests randomly generated tests"
+msg "changing to build directory '$CADICALBUILD' and running"
+cd $CADICALBUILD
+
+cmd="./mobical 42 --medium -L $tests --do-not-fork"
+cecho "${HILITE}$cmd${NORMAL}"
+$cmd
+res=$?
+
+if [ $res = 0 ]
+then
+  msg "${GOOD}all tests succeeded${NORMAL}"
+else
+  msg "${GOOD}some tests failed${NORMAL}"
+fi
+
+msg "consider to run 'mobical' for longer (without argument)"
+
+exit $res
diff --git a/hCaD_V2/test/trace/README.md b/hCaD_V2/test/trace/README.md
new file mode 100644
index 0000000..475bdbd
--- /dev/null
+++ b/hCaD_V2/test/trace/README.md
@@ -0,0 +1,6 @@
+These are regression tests in form of API traces, which are read and
+executed with the model based tester `mobical` in the build directory.
+
+The `run.sh` script is only used for `make test`.
+
+The `makefile` allows to run this tests with a single `make`.
diff --git a/hCaD_V2/test/trace/makefile b/hCaD_V2/test/trace/makefile
new file mode 100644
index 0000000..3f94d33
--- /dev/null
+++ b/hCaD_V2/test/trace/makefile
@@ -0,0 +1,3 @@
+# run the regression traces with a single 'make' call
+test:
+	$(MAKE) -C .. trace
diff --git a/hCaD_V2/test/trace/reg0000.trace b/hCaD_V2/test/trace/reg0000.trace
new file mode 100644
index 0000000..3a39f61
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0000.trace
@@ -0,0 +1,18 @@
+0 init
+1 set check 1
+2 set phase 0
+3 set reduceint 0
+4 add 4
+5 add 0
+6 add -5
+7 add -2
+8 add -4
+9 add 0
+10 add 3
+11 add 1
+12 add 0
+13 add -3
+14 add 6
+15 add 1
+16 add 0
+17 solve 0
diff --git a/hCaD_V2/test/trace/reg0001.trace b/hCaD_V2/test/trace/reg0001.trace
new file mode 100644
index 0000000..f5cbf2d
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0001.trace
@@ -0,0 +1,4 @@
+init
+solve
+solve
+reset
diff --git a/hCaD_V2/test/trace/reg0002.trace b/hCaD_V2/test/trace/reg0002.trace
new file mode 100644
index 0000000..a593df6
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0002.trace
@@ -0,0 +1,8 @@
+init
+add 1
+add 0
+solve
+add -1
+add 0
+solve
+reset
diff --git a/hCaD_V2/test/trace/reg0003.trace b/hCaD_V2/test/trace/reg0003.trace
new file mode 100644
index 0000000..0277dff
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0003.trace
@@ -0,0 +1,9 @@
+init
+add 1
+add 2
+add 0
+solve
+add -1
+add 0
+solve
+reset
diff --git a/hCaD_V2/test/trace/reg0004.trace b/hCaD_V2/test/trace/reg0004.trace
new file mode 100644
index 0000000..8c2cb4d
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0004.trace
@@ -0,0 +1,12 @@
+init
+add 1
+add 2
+add 0
+solve
+add -1
+add 0
+add -2
+add 0
+solve
+stats
+reset
diff --git a/hCaD_V2/test/trace/reg0005.trace b/hCaD_V2/test/trace/reg0005.trace
new file mode 100644
index 0000000..2a395c9
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0005.trace
@@ -0,0 +1,11 @@
+init
+add 1
+add 0
+add 2
+add 0
+solve
+add -1
+add -2
+add 0
+solve
+reset
diff --git a/hCaD_V2/test/trace/reg0006.trace b/hCaD_V2/test/trace/reg0006.trace
new file mode 100644
index 0000000..4618535
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0006.trace
@@ -0,0 +1,11 @@
+0 init
+1 set check 1
+2 add -1
+3 add 0
+4 add 2
+5 add 0
+6 solve 0
+7 add 1
+8 add -2
+9 add 0
+10 solve 0
diff --git a/hCaD_V2/test/trace/reg0007.trace b/hCaD_V2/test/trace/reg0007.trace
new file mode 100644
index 0000000..46192ac
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0007.trace
@@ -0,0 +1,7 @@
+0 init
+1 set elimint 0
+2 add 2
+3 add 0
+4 solve 0
+5 add 1
+6 add 0
diff --git a/hCaD_V2/test/trace/reg0008.trace b/hCaD_V2/test/trace/reg0008.trace
new file mode 100644
index 0000000..44f659e
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0008.trace
@@ -0,0 +1,39 @@
+0 init
+1 set elimint 0
+2 add 5
+3 add -2
+4 add 0
+5 add -4
+6 add -12
+7 add 0
+8 add 11
+9 add -5
+10 add 0
+11 add 8
+12 add -10
+13 add 0
+14 add -12
+15 add -11
+16 add 0
+17 add -3
+18 add -11
+19 add 0
+20 add -1
+21 add 3
+22 add 0
+23 add 2
+24 add -8
+25 add 0
+26 add 12
+27 add 7
+28 add 0
+29 add 1
+30 add -7
+31 add 0
+32 add 10
+33 add 11
+34 add 0
+35 solve 0
+36 add -6
+37 add -9
+38 add 0
diff --git a/hCaD_V2/test/trace/reg0009.trace b/hCaD_V2/test/trace/reg0009.trace
new file mode 100644
index 0000000..05f2574
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0009.trace
@@ -0,0 +1,7 @@
+0 init
+1 set check 1
+2 set elimint 0
+3 add -1
+4 add -2
+5 add 0
+6 solve 0
diff --git a/hCaD_V2/test/trace/reg0010.trace b/hCaD_V2/test/trace/reg0010.trace
new file mode 100644
index 0000000..2b5eb2f
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0010.trace
@@ -0,0 +1,10 @@
+0 init
+1 set check 1
+2 set elimint 0
+3 add -2
+4 add -1
+5 add 0
+6 add -3
+7 add 1
+8 add 0
+9 solve 0
diff --git a/hCaD_V2/test/trace/reg0011.trace b/hCaD_V2/test/trace/reg0011.trace
new file mode 100644
index 0000000..1b77b04
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0011.trace
@@ -0,0 +1,9 @@
+0 init
+1 set elimint 0
+2 add 1
+3 add -2
+4 add 0
+5 solve 0
+6 add -2
+7 add 0
+8 solve 0
diff --git a/hCaD_V2/test/trace/reg0012.trace b/hCaD_V2/test/trace/reg0012.trace
new file mode 100644
index 0000000..144e424
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0012.trace
@@ -0,0 +1,11 @@
+0 init
+1 set elimint 0
+2 add 2
+3 add 1
+4 add 0
+5 solve 0
+6 add 2
+7 add 0
+8 solve 0
+9 add 1
+10 add 0
diff --git a/hCaD_V2/test/trace/reg0013.trace b/hCaD_V2/test/trace/reg0013.trace
new file mode 100644
index 0000000..dbe86db
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0013.trace
@@ -0,0 +1,9 @@
+0 init
+1 set elimint 0
+2 add 2
+3 add 0
+4 solve 0
+5 add 1
+6 add 0
+7 add -1
+8 add 0
diff --git a/hCaD_V2/test/trace/reg0014.trace b/hCaD_V2/test/trace/reg0014.trace
new file mode 100644
index 0000000..4b90f8b
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0014.trace
@@ -0,0 +1,11 @@
+0 init
+1 set block 1
+2 set elimint 0
+3 add -2
+4 add 0
+5 solve 0
+6 add 2
+7 add -3
+8 add -1
+9 add 0
+10 solve 0
diff --git a/hCaD_V2/test/trace/reg0015.trace b/hCaD_V2/test/trace/reg0015.trace
new file mode 100644
index 0000000..79270d8
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0015.trace
@@ -0,0 +1,18 @@
+0 init
+1 set elimint 0
+2 add 1
+3 add -3
+4 add 0
+5 add -1
+6 add -3
+7 add 0
+8 add 3
+9 add -2
+10 add 0
+11 add 3
+12 add 2
+13 add 0
+14 solve 0
+15 add -4
+16 add 0
+17 reset
diff --git a/hCaD_V2/test/trace/reg0016.trace b/hCaD_V2/test/trace/reg0016.trace
new file mode 100644
index 0000000..081d2a1
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0016.trace
@@ -0,0 +1,15 @@
+0 init
+1 set compactint 1
+2 set compactmin 1
+3 set elimclslim 0
+4 set elimint 0
+5 set phase 0
+6 add 3
+7 add 2
+8 add 0
+9 add 2
+10 add -3
+11 add 0
+12 solve 0
+13 add 1
+14 add 0
diff --git a/hCaD_V2/test/trace/reg0017.trace b/hCaD_V2/test/trace/reg0017.trace
new file mode 100644
index 0000000..e8c2ce5
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0017.trace
@@ -0,0 +1,18 @@
+0 init
+1 set check 1
+2 set compactint 1
+3 set compactmin 1
+4 set elimint 1
+5 set phase 0
+6 set reduceint 0
+7 add -3
+8 add 2
+9 add 1
+10 add 0
+11 add 2
+12 add 3
+13 add 0
+14 solve 0
+15 add -2
+16 add 0
+17 solve 0
diff --git a/hCaD_V2/test/trace/reg0018.trace b/hCaD_V2/test/trace/reg0018.trace
new file mode 100644
index 0000000..50844e6
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0018.trace
@@ -0,0 +1,23 @@
+init
+set elimint 0
+add -3
+add 1
+add 0
+add -3
+add 2
+add 0
+add 3
+add -1
+add -2
+add 0
+solve
+val 1
+val 2
+val 3
+add 3
+add 0
+solve
+val 1
+val 2
+val 3
+reset
diff --git a/hCaD_V2/test/trace/reg0019.trace b/hCaD_V2/test/trace/reg0019.trace
new file mode 100644
index 0000000..a4e795a
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0019.trace
@@ -0,0 +1,23 @@
+init
+set elimint 0
+add -3
+add 1
+add 0
+add -3
+add 2
+add 0
+add 3
+add -1
+add -2
+add 0
+solve
+val 1
+val 2
+val 3
+add -2
+add 0
+solve
+val 1
+val 2
+val 3
+reset
diff --git a/hCaD_V2/test/trace/reg0020.trace b/hCaD_V2/test/trace/reg0020.trace
new file mode 100644
index 0000000..ae393b2
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0020.trace
@@ -0,0 +1,16 @@
+0 init
+1 set check 1
+2 set elimint 0
+3 set phase 0
+4 add -2
+5 add 4
+6 add 1
+7 add 0
+8 add -4
+9 add -3
+10 add 0
+11 add -1
+12 add 3
+13 add 0
+14 assume 2
+15 solve 0
diff --git a/hCaD_V2/test/trace/reg0021.trace b/hCaD_V2/test/trace/reg0021.trace
new file mode 100644
index 0000000..5de97c7
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0021.trace
@@ -0,0 +1,10 @@
+0 init
+1 set check 1
+2 add 1
+3 add 0
+4 assume 1
+5 assume -1
+6 solve 0
+7 failed 1
+9 failed -1
+10 reset
diff --git a/hCaD_V2/test/trace/reg0022.trace b/hCaD_V2/test/trace/reg0022.trace
new file mode 100644
index 0000000..61267ef
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0022.trace
@@ -0,0 +1,5 @@
+0 init
+1 set check 1
+2 assume -1
+3 assume 1
+4 solve 0
diff --git a/hCaD_V2/test/trace/reg0023.trace b/hCaD_V2/test/trace/reg0023.trace
new file mode 100644
index 0000000..f0d20ab
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0023.trace
@@ -0,0 +1,8 @@
+0 init
+1 set check 1
+2 assume 1
+3 assume -2
+4 add 2
+5 add -1
+6 add 0
+7 solve 0
diff --git a/hCaD_V2/test/trace/reg0024.trace b/hCaD_V2/test/trace/reg0024.trace
new file mode 100644
index 0000000..8e881cf
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0024.trace
@@ -0,0 +1,19 @@
+0 init
+1 add 6
+2 add 4
+3 add -3
+4 add 0
+5 add -4
+6 add 0
+7 add -6
+8 add -2
+9 add 0
+10 add 5
+11 add 1
+12 add 0
+13 add -5
+14 add 2
+15 add 0
+16 assume -1
+17 assume 3
+18 solve 0
diff --git a/hCaD_V2/test/trace/reg0025.trace b/hCaD_V2/test/trace/reg0025.trace
new file mode 100644
index 0000000..65fb70f
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0025.trace
@@ -0,0 +1,5 @@
+0 init
+1 add 1
+2 add 0
+3 assume -1
+4 solve 0
diff --git a/hCaD_V2/test/trace/reg0026.trace b/hCaD_V2/test/trace/reg0026.trace
new file mode 100644
index 0000000..118844d
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0026.trace
@@ -0,0 +1,23 @@
+0 init
+1 set restartmargin 0
+2 set rephaseint 0
+3 set restartint 1
+4 add 5
+5 add 6
+6 add 0
+7 add 3
+8 add 1
+9 add 0
+10 add -3
+11 add 1
+12 add 0
+13 add 8
+14 add -6
+15 add 0
+16 add -8
+17 add -6
+18 add 0
+19 assume 7
+20 assume -4
+21 assume -2
+22 solve 0
diff --git a/hCaD_V2/test/trace/reg0027.trace b/hCaD_V2/test/trace/reg0027.trace
new file mode 100644
index 0000000..285e3a4
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0027.trace
@@ -0,0 +1,86 @@
+0 init
+1 set bump 0
+2 set restartint 1
+3 set restartmargin 0
+4 add 4
+5 add 0
+6 add 7
+7 add -3
+8 add 0
+9 add -28
+10 add 0
+11 add -27
+12 add 3
+13 add 0
+14 add -11
+15 add 0
+16 add -10
+17 add 0
+18 add -18
+19 add -26
+20 add 0
+21 add -7
+22 add -1
+23 add 0
+24 add 12
+25 add 0
+26 add -6
+27 add 26
+28 add 0
+29 add -1
+30 add 13
+31 add 0
+32 add -17
+33 add 0
+34 add -7
+35 add 14
+36 add 0
+37 add -16
+38 add 5
+39 add 0
+40 add -15
+41 add 0
+42 add 6
+43 add 3
+44 add 0
+45 add 25
+46 add 0
+47 add -20
+48 add 0
+49 add -29
+50 add 0
+51 add 6
+52 add 9
+53 add 0
+54 add 23
+55 add 0
+56 add -24
+57 add 0
+58 add 16
+59 add 30
+60 add 8
+61 add 0
+62 add -9
+63 add -14
+64 add 0
+65 add -2
+66 add -30
+67 add 0
+68 add 18
+69 add -8
+70 add 0
+71 add 19
+72 add 0
+73 add -3
+74 add 13
+75 add 0
+76 add -21
+77 add 0
+78 add 16
+79 add -13
+80 add 0
+81 add -5
+82 add 27
+83 add 0
+84 assume -22
+85 solve 0
diff --git a/hCaD_V2/test/trace/reg0028.trace b/hCaD_V2/test/trace/reg0028.trace
new file mode 100644
index 0000000..4ef0f27
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0028.trace
@@ -0,0 +1,11 @@
+0 init
+1 set check 1
+2 set probeint 0
+3 add -2
+4 add -1
+5 add 0
+6 add 1
+7 add 2
+8 add 0
+9 assume 2
+10 solve 0
diff --git a/hCaD_V2/test/trace/reg0029.trace b/hCaD_V2/test/trace/reg0029.trace
new file mode 100644
index 0000000..66c787a
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0029.trace
@@ -0,0 +1,61 @@
+0 init
+2 set minimizedepth 0
+3 set restartint 1
+4 set restartmargin 0
+5 set restartreusetrail 0
+6 add 1
+7 add -4
+8 add 2
+9 add 0
+10 add 4
+11 add -1
+12 add 2
+13 add 0
+14 add 1
+15 add -2
+16 add 0
+17 add -1
+18 add 2
+19 add -5
+20 add 0
+21 add -1
+22 add 3
+23 add -2
+24 add 0
+25 assume 4
+26 add -4
+27 add -3
+28 add 0
+29 add -10
+30 add 6
+31 add 0
+32 add 3
+33 add -11
+34 add 0
+35 add 6
+36 add 11
+37 add 10
+38 add 0
+39 add 9
+40 add 0
+41 add -10
+42 add -8
+43 add 0
+44 add -6
+45 add 8
+46 add 0
+47 add 5
+48 add -8
+49 add 0
+50 solve 0
+51 add 1
+52 add 2
+53 add 0
+54 add 7
+55 add -8
+56 add 0
+57 add -7
+58 add -6
+59 add 0
+60 assume 9
+61 solve 0
diff --git a/hCaD_V2/test/trace/reg0030.trace b/hCaD_V2/test/trace/reg0030.trace
new file mode 100644
index 0000000..a874285
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0030.trace
@@ -0,0 +1,29 @@
+0 init
+1 set check 1
+2 set compactint 1
+3 set compactmin 1
+4 add 4
+5 add -5
+6 add 0
+7 add -4
+8 add 3
+9 add 0
+10 add -2
+11 add -3
+12 add 0
+13 add -6
+14 add -2
+15 add 0
+16 add 6
+17 add -1
+18 add 0
+19 add 2
+20 add -4
+21 add 0
+22 add -6
+23 add 2
+24 add 0
+25 solve 0
+26 assume 5
+27 assume -7
+28 solve 0
diff --git a/hCaD_V2/test/trace/reg0031.trace b/hCaD_V2/test/trace/reg0031.trace
new file mode 100644
index 0000000..3b48a9d
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0031.trace
@@ -0,0 +1,44 @@
+init
+set block 1
+set check 1
+set compactint 1
+set compactlim 0
+set compactmin 1
+set elimint 0
+set elimint 1
+set reduceint 0
+set elimclslim 3
+add -4
+add -2
+add 0
+add -1
+add -16
+add 0
+add 6
+add 4
+add 0
+add 2
+add 16
+add 0
+add 8
+add -11
+add 1
+add 0
+add -8
+add 5
+add 0
+add 3
+add -6
+add 0
+assume -3
+add -5
+add -11
+add -10
+add 0
+add 11
+add 7
+add 0
+assume 10
+assume -94
+assume -7
+solve 0
diff --git a/hCaD_V2/test/trace/reg0032.trace b/hCaD_V2/test/trace/reg0032.trace
new file mode 100644
index 0000000..9dfca82
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0032.trace
@@ -0,0 +1,12 @@
+0 init
+1 set elimint 0
+2 add -1
+3 add -2
+4 add 0
+5 add -1
+6 add 2
+7 add 0
+8 assume 1
+9 solve 0
+10 assume -2
+11 solve 0
diff --git a/hCaD_V2/test/trace/reg0033.trace b/hCaD_V2/test/trace/reg0033.trace
new file mode 100644
index 0000000..bd5d7cf
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0033.trace
@@ -0,0 +1,27 @@
+init
+set elimint 0
+freeze -1
+add 1
+add 2
+add 0
+freeze 1
+freeze 2
+melt -1
+add -1
+add -2
+add 0
+frozen 1
+frozen 2
+solve
+frozen 1
+frozen 2
+val 1
+val 2
+melt 1
+frozen 1
+frozen 2
+solve
+val 1
+val 2
+frozen 1
+frozen 2
diff --git a/hCaD_V2/test/trace/reg0034.trace b/hCaD_V2/test/trace/reg0034.trace
new file mode 100644
index 0000000..b0c03c4
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0034.trace
@@ -0,0 +1,10 @@
+0 init
+1 set compactint 1
+2 set compactmin 1
+3 add 1
+4 add -4
+5 add 0
+6 add -1
+7 add -4
+8 add 0
+9 solve 0
diff --git a/hCaD_V2/test/trace/reg0035.trace b/hCaD_V2/test/trace/reg0035.trace
new file mode 100644
index 0000000..11e4bc1
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0035.trace
@@ -0,0 +1,19 @@
+0 init
+1 set compactint 1
+2 set compactmin 1
+3 add 2
+4 add -1
+5 add 0
+6 add -1
+7 add -2
+8 add 0
+9 assume -4
+10 assume 1
+11 solve 0
+12 add -3
+13 add -4
+14 add 0
+15 add 4
+16 add -3
+17 add 0
+18 solve 0
diff --git a/hCaD_V2/test/trace/reg0036.trace b/hCaD_V2/test/trace/reg0036.trace
new file mode 100644
index 0000000..33888cc
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0036.trace
@@ -0,0 +1,9 @@
+0 init
+set check 1
+set checkfailed 1
+1 assume 1
+2 add -1
+3 add 2
+4 add 0
+5 assume -2
+6 solve 0
diff --git a/hCaD_V2/test/trace/reg0037.trace b/hCaD_V2/test/trace/reg0037.trace
new file mode 100644
index 0000000..29fad88
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0037.trace
@@ -0,0 +1,21 @@
+0 init
+1 set elimint 0
+2 add 4
+3 add 2
+4 add 0
+5 add 4
+6 add 3
+7 add 0
+8 add -2
+9 add -1
+10 add 0
+11 add -3
+12 add -4
+13 add 0
+14 add 3
+15 add -4
+16 add 0
+17 add 1
+18 add -3
+19 add 0
+20 solve 0
diff --git a/hCaD_V2/test/trace/reg0038.trace b/hCaD_V2/test/trace/reg0038.trace
new file mode 100644
index 0000000..755067d
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0038.trace
@@ -0,0 +1,32 @@
+init
+vars
+active
+redundant
+irredundant
+fixed 1
+fixed 2
+reserve 2
+fixed 1
+fixed 2
+add 2
+add 0
+vars
+active
+redundant
+irredundant
+fixed 1
+fixed 2
+fixed -1
+fixed -2
+add 1
+add 4
+add 0
+vars
+active
+redundant
+irredundant
+fixed 1
+fixed 2
+fixed -1
+fixed -2
+reset
diff --git a/hCaD_V2/test/trace/reg0039.trace b/hCaD_V2/test/trace/reg0039.trace
new file mode 100644
index 0000000..4dfe510
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0039.trace
@@ -0,0 +1,12 @@
+0 init
+1 set elimint 0
+2 add 1
+3 add 2
+4 add 0
+5 add -2
+6 add 1
+7 add 0
+8 add -2
+9 add -1
+10 add 0
+11 solve 0
diff --git a/hCaD_V2/test/trace/reg0040.trace b/hCaD_V2/test/trace/reg0040.trace
new file mode 100644
index 0000000..a561ea4
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0040.trace
@@ -0,0 +1,28 @@
+0 init
+1 set probe 0
+2 limit preprocessing 1
+3 set transred 0
+4 add 1
+5 add -3
+6 add 0
+7 add 2
+8 add -1
+9 add 0
+10 add 1
+11 add -2
+12 add 0
+13 add 1
+14 add 2
+15 add 0
+16 freeze 2
+17 add 4
+18 add 3
+19 add 0
+20 add 4
+21 add 3
+22 add 0
+23 add 3
+24 add 4
+25 add 0
+26 assume 4
+27 solve 0
diff --git a/hCaD_V2/test/trace/reg0041.trace b/hCaD_V2/test/trace/reg0041.trace
new file mode 100644
index 0000000..abdd7cc
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0041.trace
@@ -0,0 +1,62 @@
+0 init
+1 limit preprocessing 1
+2 set vivify 0
+3 add 3
+4 add 1
+5 add 2
+6 add 0
+7 add 4
+8 add 2
+9 add 3
+10 add 0
+11 add 3
+12 add -1
+13 add -4
+14 add 2
+15 add 0
+16 add 1
+17 add 4
+18 add 3
+19 add 0
+20 add -4
+21 add 2
+22 add 3
+23 add -1
+24 add 0
+25 add 4
+26 add -3
+27 add -1
+28 add 2
+29 add 0
+30 add -1
+31 add -2
+32 add 0
+33 add -1
+34 add -3
+35 add -4
+36 add 0
+37 add -2
+38 add 1
+39 add -3
+40 add -4
+41 add 0
+42 add -4
+43 add -3
+44 add 2
+45 add 0
+46 add 3
+47 add -1
+48 add 2
+49 add -4
+50 add 0
+51 add -4
+52 add -1
+53 add 3
+54 add -2
+55 add 0
+56 add -4
+57 add 1
+58 add 3
+59 add -2
+60 add 0
+61 solve 0
diff --git a/hCaD_V2/test/trace/reg0042.trace b/hCaD_V2/test/trace/reg0042.trace
new file mode 100644
index 0000000..1542c6c
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0042.trace
@@ -0,0 +1,35 @@
+init
+limit preprocessing 1
+set probe 0
+set vivify 0
+set subsume 0
+set transred 0
+freeze 1
+freeze 2
+freeze 4
+freeze 5
+add -3
+add 1
+add 0
+add -3
+add 2
+add 0
+add 3
+add -1
+add -2
+add 0
+add -3
+add 4
+add 0
+add 3
+add 5
+add 0
+add -4
+add -5
+add 0
+dump
+limit conflicts 0
+solve
+dump
+stats
+reset
diff --git a/hCaD_V2/test/trace/reg0043.trace b/hCaD_V2/test/trace/reg0043.trace
new file mode 100644
index 0000000..2911e67
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0043.trace
@@ -0,0 +1,27 @@
+init
+set check 1
+set checkfrozen 1
+add 1
+add 2
+add 3
+add 0
+add -1
+add -2
+add -3
+add 0
+freeze 1
+freeze 2
+solve
+add -1
+add 2
+add 0
+add -1
+add 2
+add 0
+melt 2
+solve
+melt 1
+add 1
+add 0
+solve
+reset
diff --git a/hCaD_V2/test/trace/reg0044.trace b/hCaD_V2/test/trace/reg0044.trace
new file mode 100644
index 0000000..1d11e20
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0044.trace
@@ -0,0 +1,10 @@
+init
+set phase 0
+set walk 1
+add 1
+add 2
+add 0
+assume -2
+assume -1
+limit localsearch 1
+solve 0
diff --git a/hCaD_V2/test/trace/reg0045.trace b/hCaD_V2/test/trace/reg0045.trace
new file mode 100644
index 0000000..b20a7c8
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0045.trace
@@ -0,0 +1,13 @@
+init
+set phase 0
+set walk 1
+add 1
+add 2
+add 3
+add 0
+assume -2
+assume -1
+assume 1
+assume 2
+limit localsearch 1
+solve 0
diff --git a/hCaD_V2/test/trace/reg0046.trace b/hCaD_V2/test/trace/reg0046.trace
new file mode 100644
index 0000000..0edc673
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0046.trace
@@ -0,0 +1,12 @@
+init
+set walk 1
+set walkmineff 10
+add 1
+add 2
+add 0
+add 1
+add -2
+add 0
+assume -1
+limit localsearch 1
+solve 0
diff --git a/hCaD_V2/test/trace/reg0047.trace b/hCaD_V2/test/trace/reg0047.trace
new file mode 100644
index 0000000..f0caeab
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0047.trace
@@ -0,0 +1,12 @@
+init
+set walkmineff 5
+add 2
+add -1
+add 0
+add 3
+add 1
+add 0
+assume -2
+assume -3
+limit localsearch 1
+solve 0
diff --git a/hCaD_V2/test/trace/reg0048.trace b/hCaD_V2/test/trace/reg0048.trace
new file mode 100644
index 0000000..fdb6bb3
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0048.trace
@@ -0,0 +1,69 @@
+init
+set check 1
+set cover 1
+set elimint 11
+set elimocclim 0
+set restoreflush 1
+set subsumemineff 0
+set subsumestr 0
+set vivifymineff 0
+add 2
+add -3
+add -6
+add 0
+add 2
+add 5
+add -3
+add 0
+add 5
+add -2
+add 4
+add 3
+add 0
+add 4
+add -2
+add -3
+add 0
+add -4
+add 3
+add 6
+add 0
+add -4
+add 3
+add -2
+add 0
+add -6
+add -8
+add 2
+add -4
+add -7
+add 0
+add -3
+add -4
+add -2
+add 0
+add -8
+add 4
+add 3
+add 2
+add 0
+add 3
+add -7
+add 8
+add 0
+add -2
+add -7
+add 3
+add -5
+add 0
+add -5
+add -3
+add 2
+add 0
+add 7
+add 2
+add 0
+solve 0
+add 7
+add 0
+solve 0
diff --git a/hCaD_V2/test/trace/reg0049.trace b/hCaD_V2/test/trace/reg0049.trace
new file mode 100644
index 0000000..05b066e
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0049.trace
@@ -0,0 +1,28 @@
+0 init
+set restoreflush 1
+set cover 1
+1 set deduplicate 0
+2 set elimocclim 0
+3 set covermineff 0
+4 set decompose 0
+5 set lucky 0
+6 add 1
+7 add -2
+8 add -3
+9 add 0
+10 add -1
+11 add 2
+12 add 0
+13 add -2
+14 add -1
+15 add 0
+16 solve 0
+17 add 2
+18 add -3
+19 add 0
+20 add 3
+21 add 2
+22 add 0
+23 limit preprocessing 1
+24 limit localsearch 1
+25 solve 0
diff --git a/hCaD_V2/test/trace/reg0050.trace b/hCaD_V2/test/trace/reg0050.trace
new file mode 100644
index 0000000..05b066e
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0050.trace
@@ -0,0 +1,28 @@
+0 init
+set restoreflush 1
+set cover 1
+1 set deduplicate 0
+2 set elimocclim 0
+3 set covermineff 0
+4 set decompose 0
+5 set lucky 0
+6 add 1
+7 add -2
+8 add -3
+9 add 0
+10 add -1
+11 add 2
+12 add 0
+13 add -2
+14 add -1
+15 add 0
+16 solve 0
+17 add 2
+18 add -3
+19 add 0
+20 add 3
+21 add 2
+22 add 0
+23 limit preprocessing 1
+24 limit localsearch 1
+25 solve 0
diff --git a/hCaD_V2/test/trace/reg0051.trace b/hCaD_V2/test/trace/reg0051.trace
new file mode 100644
index 0000000..c70db59
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0051.trace
@@ -0,0 +1,39 @@
+init
+set cover 1
+set restoreflush 1
+set check 1
+set elimocclim 0
+set proberounds 0
+set subsume 0
+set vivifymineff 0
+add -2
+add -4
+add 1
+add 0
+add 1
+add 4
+add 3
+add 2
+add 0
+add 2
+add -1
+add 0
+add -1
+add -3
+add 0
+add 1
+add -3
+add 4
+add 0
+add -2
+add 4
+add 0
+add -4
+add 3
+add 0
+assume -3
+limit preprocessing 1
+solve 0
+add 2
+add 0
+solve 0
diff --git a/hCaD_V2/test/trace/reg0052.trace b/hCaD_V2/test/trace/reg0052.trace
new file mode 100644
index 0000000..f2945b1
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0052.trace
@@ -0,0 +1,67 @@
+0 init
+1 set check 1
+2 set elimint 2
+3 set phase 0
+4 set lucky 0
+5 add -67
+6 add -89
+7 add 0
+8 add 67
+9 add 75
+10 add 0
+11 add -70
+12 add 56
+13 add 0
+14 add -85
+15 add -75
+16 add 0
+17 add 85
+18 add -53
+19 add 0
+20 add 54
+21 add -53
+22 add 0
+23 add 50
+24 add 56
+25 add 70
+26 add 0
+27 add 82
+28 add -93
+29 add 0
+30 add -79
+31 add -62
+32 add 0
+33 add -82
+34 add -54
+35 add 89
+36 add 0
+37 add -62
+38 add -48
+39 add -50
+40 add 0
+41 add 53
+42 add 79
+43 add 0
+44 add -50
+45 add 62
+46 add 0
+47 assume 48
+48 assume -56
+49 freeze -79
+50 solve 0
+51 add 99
+52 add -112
+53 add 0
+54 add 97
+55 add 93
+56 add 0
+57 add 123
+58 add -97
+59 add 0
+60 add -99
+61 add 140
+62 add 0
+63 add 112
+64 add -123
+65 add 0
+66 solve 0
diff --git a/hCaD_V2/test/trace/reg0053.trace b/hCaD_V2/test/trace/reg0053.trace
new file mode 100644
index 0000000..8acf01e
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0053.trace
@@ -0,0 +1,3 @@
+0 init
+1 set lucky 0
+2 lookahead 0
diff --git a/hCaD_V2/test/trace/reg0054.trace b/hCaD_V2/test/trace/reg0054.trace
new file mode 100644
index 0000000..da9bd65
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0054.trace
@@ -0,0 +1,5 @@
+0 init
+1 add 1
+2 add 2
+3 add 0
+4 lookahead 0
diff --git a/hCaD_V2/test/trace/reg0055.trace b/hCaD_V2/test/trace/reg0055.trace
new file mode 100644
index 0000000..80ec7ae
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0055.trace
@@ -0,0 +1,14 @@
+0 init
+1 add -1
+2 add 2
+3 add 0
+4 add -2
+5 add -1
+6 add 0
+7 add -2
+8 add 1
+9 add 0
+10 add 1
+11 add 2
+12 add 0
+13 lookahead 0
diff --git a/hCaD_V2/test/trace/reg0056.trace b/hCaD_V2/test/trace/reg0056.trace
new file mode 100644
index 0000000..a725208
--- /dev/null
+++ b/hCaD_V2/test/trace/reg0056.trace
@@ -0,0 +1,393 @@
+0 init
+1 set check 1
+2 set vivify 0
+3 set elimboundmin -1
+4 set elimclslim 5
+5 set lucky 0
+6 set elimsubst 0
+7 set probe 0
+8 set arena 0
+9 set arenacompact 0
+10 set arenasort 0
+11 set arenatype 1
+12 set binary 0
+13 set block 0
+14 set bump 0
+15 set bumpreason 0
+16 set bumpreasondepth 1
+17 set checkassumptions 0
+18 set checkfailed 0
+19 set checkproof 0
+20 set checkwitness 1
+21 set chrono 0
+22 set chronoalways 0
+23 set chronolevelim 0
+24 set chronoreusetrail 0
+25 set compact 0
+26 set compactint 1
+27 set compactlim 0
+28 set compactmin 1
+29 set condition 0
+30 set cover 0
+31 set decompose 0
+32 set decomposerounds 1
+33 set deduplicate 0
+34 set eagersubsume 0
+35 set eagersubsumelim 1
+36 set elim 1
+37 set elimands 0
+38 set elimaxeff 0
+39 set elimbackward 0
+40 set elimboundmax -1
+41 set elimequivs 0
+42 set elimineff 0
+43 set elimint 1
+44 set elimites 0
+45 set elimlimited 0
+46 set elimocclim 25
+47 set elimprod 1
+48 set elimreleff 1
+49 set elimrounds 1
+50 set elimsum 0
+51 set elimxorlim 2
+52 set elimxors 0
+53 set emagluefast 1
+54 set emaglueslow 1
+55 set emajump 1
+56 set emalevel 1
+57 set emasize 1
+58 set ematrailfast 1
+59 set ematrailslow 1
+60 set flush 0
+61 set forcephase 0
+62 set inprocessing 0
+63 set instantiate 0
+64 set minimize 0
+65 set minimizedepth 0
+66 set phase 1
+67 set profile 0
+68 set quiet 0
+69 set radixsortlim 0
+70 set realtime 0
+71 set reduceint 10
+72 set reducetarget 10
+73 set reducetier1glue 1
+74 set reducetier2glue 1
+75 set reluctant 0
+76 set reluctantmax 0
+77 set rephase 0
+78 set rephaseint 1
+79 set report 0
+80 set restart 0
+81 set restartint 1
+82 set restartmargin 0
+83 set restartreusetrail 0
+84 set restoreall 0
+85 set restoreflush 0
+86 set reverse 0
+87 set score 0
+88 set scorefactor 500
+89 set seed 0
+90 set shrink 0
+91 set shrinkreap 0
+92 set shuffle 0
+93 set stabilize 0
+94 set stabilizefactor 101
+95 set stabilizeint 1
+96 set stabilizemaxint 1
+97 set stabilizeonly 0
+98 set subsume 1
+99 set subsumebinlim 0
+100 set subsumeclslim 6
+101 set subsumeint 1
+102 set subsumelimited 0
+103 set subsumemaxeff 0
+104 set subsumemineff 0
+105 set subsumeocclim 3
+106 set subsumereleff 1
+107 set subsumestr 1
+108 set target 0
+109 set ternary 0
+110 set ternarymaxadd 0
+111 set ternarymaxeff 0
+112 set ternarymineff 1
+113 set ternaryocclim 1
+114 set ternaryreleff 1
+115 set ternaryrounds 1
+116 set transred 0
+117 set transredmaxeff 0
+118 set transredmineff 0
+119 set transredreleff 1
+120 set verbose 4
+120 set log 1
+121 set walk 0
+122 set walkmaxeff 0
+123 set walkmineff 0
+124 set walknonstable 0
+125 set walkredundant 0
+126 set walkreleff 1
+127 add -4
+128 add 1
+129 add 0
+130 add 5
+131 add -3
+132 add 0
+133 add 1
+134 add 3
+135 add 7
+136 add 0
+137 add -6
+138 add 4
+139 add 8
+140 add -7
+141 add -1
+142 add 0
+143 add 3
+144 add 4
+145 add 0
+146 add 3
+147 add -5
+148 add 6
+149 add 0
+150 add 2
+151 add -3
+152 add 1
+153 add 0
+154 add -4
+155 add -5
+156 add 0
+157 add 5
+158 add 2
+159 add 0
+160 add 6
+161 add 2
+162 add 4
+163 add 0
+164 solve 0
+165 add 12
+166 add 11
+167 add 7
+168 add 1
+169 add 0
+170 add -10
+171 add -7
+172 add -11
+173 add 0
+174 add 12
+175 add -11
+176 add 7
+177 add 9
+178 add -8
+179 add 0
+180 add 7
+181 add 8
+182 add -12
+183 add -11
+184 add 0
+185 add 11
+186 add 12
+187 add 1
+188 add -9
+189 add 8
+190 add 0
+191 add 8
+192 add -11
+193 add 7
+194 add 10
+195 add 0
+196 add 7
+197 add -12
+198 add -11
+199 add 10
+200 add -8
+201 add 0
+202 add -10
+203 add -8
+204 add 11
+205 add 7
+206 add -9
+207 add 0
+208 add 9
+209 add -12
+210 add -10
+211 add 7
+212 add -8
+213 add 0
+214 add 11
+215 add 7
+216 add -12
+217 add 10
+218 add -8
+219 add 0
+220 add 9
+221 add 7
+222 add 8
+223 add 11
+224 add -10
+225 add 0
+226 add 10
+227 add 11
+228 add -12
+229 add -8
+230 add -7
+231 add 0
+232 add 9
+233 add -8
+234 add 11
+235 add -7
+236 add 0
+237 add -9
+238 add 12
+239 add 8
+240 add 11
+241 add 7
+242 add 0
+243 add 10
+244 add 12
+245 add -9
+246 add 11
+247 add -8
+248 add 0
+249 add -8
+250 add -10
+251 add -9
+252 add -7
+253 add -12
+254 add 0
+255 add 11
+256 add 12
+257 add -10
+258 add -9
+259 add -7
+260 add 0
+261 add 12
+262 add 8
+263 add 9
+264 add 7
+265 add 10
+266 add 0
+267 add -12
+268 add 9
+269 add -10
+270 add 7
+271 add -11
+272 add 0
+273 add 11
+274 add 9
+275 add 10
+276 add -8
+277 add 0
+278 add -12
+279 add -9
+280 add -10
+281 add 8
+282 add 0
+283 add -8
+284 add -10
+285 add -11
+286 add 7
+287 add 9
+288 add 0
+289 add -10
+290 add 9
+291 add 11
+292 add 8
+293 add -12
+294 add 0
+295 add -8
+296 add -7
+297 add 2
+298 add 0
+299 add -8
+300 add 12
+301 add -10
+302 add -9
+303 add 0
+304 add 10
+305 add -8
+306 add 7
+307 add 12
+308 add -9
+309 add 0
+310 add 12
+311 add -9
+312 add 8
+313 add -7
+314 add 10
+315 add 0
+316 add -11
+317 add -8
+318 add 10
+319 add -12
+320 add 9
+321 add 0
+322 add -11
+323 add -7
+324 add 9
+325 add 8
+326 add 0
+327 add 1
+328 add -8
+329 add 9
+330 add 12
+331 add 10
+332 add 0
+333 add 8
+334 add -7
+335 add -12
+336 add 10
+337 add 0
+338 add 12
+339 add 7
+340 add 1
+341 add 8
+342 add 0
+343 add -9
+344 add 7
+345 add -12
+346 add -11
+347 add 0
+348 add -10
+349 add -8
+350 add 9
+351 add 11
+352 add 12
+353 add 0
+354 add -7
+355 add -9
+356 add 10
+357 add -8
+358 add 0
+359 add -11
+360 add 12
+361 add -8
+362 add 10
+363 add 0
+364 add -10
+365 add -11
+366 add 8
+367 add -12
+368 add 0
+369 add 10
+370 add 7
+371 add -9
+372 add -12
+373 add 0
+374 add -10
+375 add 12
+376 add 9
+377 add -7
+378 add 0
+379 add 8
+380 add 11
+381 add 7
+382 add 10
+383 add -12
+384 add 0
+385 add -11
+386 add 7
+387 add 8
+388 add -1
+389 add 0
+390 limit preprocessing 1
+391 solve 0
diff --git a/hCaD_V2/test/trace/run.sh b/hCaD_V2/test/trace/run.sh
new file mode 100644
index 0000000..de15ef8
--- /dev/null
+++ b/hCaD_V2/test/trace/run.sh
@@ -0,0 +1,96 @@
+#!/bin/sh
+
+die () {
+  cecho "${HIDE}test/trace/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  exit 1
+}
+
+msg () {
+  cecho "${HIDE}test/trace/run.sh:${NORMAL} $*"
+}
+
+for dir in . .. ../..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+[ -d ../test -a -d ../test/trace ] || \
+die "needs to be called from a top-level sub-directory of CaDiCaL"
+
+[ x"$CADICALBUILD" = x ] && CADICALBUILD="../build"
+
+[ -x "$CADICALBUILD/cadical" ] || \
+  die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
+
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "Regression Testing API traces in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
+
+cd $CADICALBUILD || exit 1
+make
+res=$?
+[ $res = 0 ] || exit $res
+
+
+#--------------------------------------------------------------------------#
+
+ok=0
+failed=0
+executed=0
+
+run () {
+  msg "running ${HILITE}'$1'${NORMAL}"
+  trace=../test/trace/$1.trace
+  executed=`expr $executed + 1`
+  cecho "$CADICALBUILD/mobical $trace"
+  $CADICALBUILD/mobical $trace 2>/dev/null 1>/dev/null
+  res=$?
+  cecho $res
+  if [ $res = 0 ]
+  then
+    cecho "# ... ${GOOD}ok${NORMAL}"
+    ok=`expr $ok + 1`
+  else
+    cecho "# ... ${BAD}failed${NORMAL}"
+    failed=`expr $failed + 1`
+  fi
+}
+
+#--------------------------------------------------------------------------#
+
+traces="`ls ../test/trace/*.trace|sed -e 's,.*/,,' -e 's,\.trace$,,'`"
+numtraces="`echo $traces|wc -w`"
+msg "found $numtraces traces"
+
+for trace in $traces ignore
+do
+  [ $trace = ignore ] && continue
+  run $trace
+done
+
+#--------------------------------------------------------------------------#
+
+if [ $failed -gt 0 ]
+then
+  OK=""
+  FAILED=$BAD
+elif [ $ok -gt 0 ]
+then
+  OK=$GOOD
+  FAILED=""
+else
+  OK=""
+  FAILED=""
+fi
+
+msg "executed $executed traces," \
+    "${OK}$ok ok${NORMAL}," \
+    "${FAILED}$failed failed$NORMAL"
+
+exit $failed
diff --git a/hCaD_V2/test/usage/README.md b/hCaD_V2/test/usage/README.md
new file mode 100644
index 0000000..84ea1a8
--- /dev/null
+++ b/hCaD_V2/test/usage/README.md
@@ -0,0 +1,8 @@
+These are some simple hard coded usage tests of the `cadical` solver binary
+executed by `run.sh` which actually needs to be called from an immediate
+sub-directory of CaDiCaL (such as the directory `..` one level up).  Log and
+proof files are saved in the build directory.
+
+The `makefile` allows to execute the CNF tests from within this
+sub-directory with a single `make` command, but always uses `cadical`
+from `../../build/` and also puts the log and error files there.
diff --git a/hCaD_V2/test/usage/makefile b/hCaD_V2/test/usage/makefile
new file mode 100644
index 0000000..f93291c
--- /dev/null
+++ b/hCaD_V2/test/usage/makefile
@@ -0,0 +1,3 @@
+# execute usage tests with a single 'make' command in '../../build'
+test:
+	$(MAKE) -C .. usage
diff --git a/hCaD_V2/test/usage/missing-clause.cnf b/hCaD_V2/test/usage/missing-clause.cnf
new file mode 100644
index 0000000..a6977ba
--- /dev/null
+++ b/hCaD_V2/test/usage/missing-clause.cnf
@@ -0,0 +1,2 @@
+p cnf 1 0
+1 0
diff --git a/hCaD_V2/test/usage/relaxed-header.cnf b/hCaD_V2/test/usage/relaxed-header.cnf
new file mode 100644
index 0000000..c5947ad
--- /dev/null
+++ b/hCaD_V2/test/usage/relaxed-header.cnf
@@ -0,0 +1,5 @@
+p   cnf   	1		  3   
+	1  	0	
+	-1  0
+  1
+0
diff --git a/hCaD_V2/test/usage/run.sh b/hCaD_V2/test/usage/run.sh
new file mode 100644
index 0000000..03b1f1d
--- /dev/null
+++ b/hCaD_V2/test/usage/run.sh
@@ -0,0 +1,149 @@
+#!/bin/sh
+
+#--------------------------------------------------------------------------#
+
+die () {
+  cecho "${HIDE}test/usage/run.sh:${NORMAL} ${BAD}error:${NORMAL} $*"
+  exit 1
+}
+
+msg () {
+  cecho "${HIDE}test/usage/run.sh:${NORMAL} $*"
+}
+
+for dir in . .. ../..
+do
+  [ -f $dir/scripts/colors.sh ] || continue
+  . $dir/scripts/colors.sh || exit 1
+  break
+done
+
+#--------------------------------------------------------------------------#
+
+[ -d ../test -a -d ../test/cnf ] || \
+die "needs to be called from a top-level sub-directory of CaDiCaL"
+
+[ x"$CADICALBUILD" = x ] && CADICALBUILD="../build"
+
+[ -x "$CADICALBUILD/cadical" ] || \
+  die "can not find '$CADICALBUILD/cadical' (run 'make' first)"
+
+cecho -n "$HILITE"
+cecho "---------------------------------------------------------"
+cecho "usage testing in '$CADICALBUILD'" 
+cecho "---------------------------------------------------------"
+cecho -n "$NORMAL"
+
+make -C $CADICALBUILD
+res=$?
+[ $res = 0 ] || exit $res
+
+#--------------------------------------------------------------------------#
+
+solver="$CADICALBUILD/cadical"
+
+#--------------------------------------------------------------------------#
+
+cecho "starting test run `pwd`"
+
+ok=0
+failed=0
+
+run () {
+  expected="$1"
+  options=`echo "$*"|sed -e 's,[^ ]*,,'`
+  name=`echo "@-$options"|sed -e 's,\.\./test/.*/,,g' -e 's,\.cnf\>,,g' -e 's,@,,' -e 's,[ \./],-,g' -e 's,--*,-,g'`
+  msg "running usage test ${HILITE}'test-usage$name'${NORMAL}"
+  buildprefix="$CADICALBUILD/test-usage$name"
+  log="$buildprefix.log"
+  err="$buildprefix.err"
+  cmd="$solver $options"
+  cecho -n "$cmd"
+  $cmd 1>$log 2>$err
+  res=$?
+  if [ $res = $expected ]
+  then
+    cecho " # ${GOOD}ok${NORMAL} (expected exit code '$res')"
+    ok=`expr $ok + 1`
+  else
+    cecho " # ${BAD}FAILED${NORMAL} (unexpected exit code '$res')"
+    failed=`expr $failed + 1`
+  fi
+}
+
+run 0 -h
+run 0 --help
+run 0 --version
+run 0 --build
+run 0 --copyright
+
+run 10 ../test/cnf/empty.cnf
+run 20 ../test/cnf/false.cnf
+
+if [ x"`$solver --build 2>/dev/null|grep QUIET`" = x ]
+then
+  run 10 -n ../test/cnf/empty.cnf
+  run 10 -v ../test/cnf/empty.cnf
+  run 10 -v -v ../test/cnf/empty.cnf
+  run 10 -v -v -v ../test/cnf/empty.cnf
+  run 10 -q ../test/cnf/empty.cnf
+fi
+
+run 1 ../test/usage/missing-clause.cnf
+run 1 ../test/usage/variable-too-large.cnf
+run 1 --strict relaxed-header.cnf
+
+for option in "-f" "--force" "--force=1" "--force=true"
+do
+  run 10 $option ../test/usage/missing-clause.cnf
+  run 10 $option ../test/usage/variable-too-large.cnf
+done
+
+run 20 ../test/usage/relaxed-header.cnf
+
+# TODO:  still need to add test cases for these:
+
+for option in -O1 -O2 -O3
+do
+  run 10 $option ../test/cnf/prime2209.cnf
+done
+
+for option in -L1 -L2 -L10
+do
+  run 10 $option ../test/cnf/prime9.cnf
+done
+
+for option in -P1 -P2 -P16 -P128 -P1024
+do
+  run 20 $option ../test/cnf/add16.cnf
+done
+
+# run 0 -t
+# run 0 -O
+# run 0 -c 0
+# run 0 -c 1
+# run 0 -c 2
+# run 0 -d 0
+# run 0 -d 1
+# run 0 -d 2
+
+# run 0 --colors # TODO all versions ....
+# run 0 --no-colors # TODO all versions ....
+# run 0 --no-leak # not needed
+
+#--------------------------------------------------------------------------#
+
+# not needed since tested in '../cnf'
+
+# run 0 -o # working version not needed since testet in CNF tests
+# run 0 -e # working version not needed since testet in CNF tests
+# run 0 -s # working version not needed since tested in CNF tests
+
+#--------------------------------------------------------------------------#
+
+[ $ok -gt 0 ] && OK="$GOOD"
+[ $failed -gt 0 ] && FAILED="$BAD"
+
+msg "${HILITE}usage testing results:${NORMAL} ${OK}$ok ok${NORMAL}, ${FAILED}$failed failed${NORMAL}"
+
+exit $failed
diff --git a/hCaD_V2/test/usage/variable-too-large.cnf b/hCaD_V2/test/usage/variable-too-large.cnf
new file mode 100644
index 0000000..1fbbf48
--- /dev/null
+++ b/hCaD_V2/test/usage/variable-too-large.cnf
@@ -0,0 +1,2 @@
+p cnf 0 1
+1 0
diff --git a/hash_val.cpp b/hash_val.cpp
new file mode 100644
index 0000000..80adcf9
--- /dev/null
+++ b/hash_val.cpp
@@ -0,0 +1,50 @@
+/*------------------------------------------------------------------------*/
+/*! \file hash_val.cpp
+    \brief contains functions used to compute hash values for variables
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#include <random>
+
+#include "hash_val.h"
+/*------------------------------------------------------------------------*/
+// Local variables
+
+// / array used to hold 64-bit random numbers
+uint64_t nonces[32];
+
+// / number of random numbers
+const size_t num_nonces = sizeof nonces / sizeof nonces[0];
+
+std::random_device rd;
+std::mt19937_64 gen(42);
+std::uniform_int_distribution<unsigned long long> dis;
+/*------------------------------------------------------------------------*/
+
+
+void init_nonces() {
+  for (size_t i = 0; i < num_nonces; i++)
+    nonces[i] = dis(gen) | 1;
+}
+
+/*------------------------------------------------------------------------*/
+
+uint64_t get_nonces_entry(size_t index) {
+  assert(index < 32);
+  return nonces[index];
+}
+
+/*------------------------------------------------------------------------*/
+
+uint64_t hash_string(const std::string& str) {
+  uint64_t res = 0;
+  size_t i = 0;
+  for (std::string::const_iterator it = str.cbegin(); it != str.cend(); ++it) {
+    res += *it;
+    res *= nonces[i++];
+    if (i == num_nonces) i = 0;
+  }
+  return res;
+}
diff --git a/hash_val.h b/hash_val.h
new file mode 100644
index 0000000..ea18cbb
--- /dev/null
+++ b/hash_val.h
@@ -0,0 +1,41 @@
+/*------------------------------------------------------------------------*/
+/*! \file hash_val.h
+    \brief contains functions used to compute hash values for variables
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#ifndef AMULET2_SRC_HASH_VAL_H_
+#define AMULET2_SRC_HASH_VAL_H_
+/*------------------------------------------------------------------------*/
+#include <assert.h>
+
+#include <string>
+/*------------------------------------------------------------------------*/
+
+
+/**
+    Fills a 32-bit array with 64-bit random numbers
+*/
+void init_nonces();
+
+/**
+    Returns the 64-bit random number in our array of random numbers
+
+    @param index size_t
+
+    @return returns the random number stored in nonces[index]
+*/
+uint64_t get_nonces_entry(size_t index);
+
+/**
+    Computes the hash value for the given string
+
+    @param str a const std::string
+
+    @return a uint64_t computed hash value for the input string
+*/
+uint64_t hash_string(const std::string& str);
+
+#endif  // AMULET2_SRC_HASH_VAL_H_
diff --git a/m4gb b/m4gb
deleted file mode 160000
index 0a166c8..0000000
--- a/m4gb
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 0a166c87ab7d156ccbbff807a0ad1ec50cff8d83
diff --git a/makefile b/makefile
index 6f52d4f..ffb90d0 100644
--- a/makefile
+++ b/makefile
@@ -6,9 +6,9 @@ OBJS = $(addprefix $(BUILD_DIR), $(addsuffix .o, $(basename $(SRCS))))
 
 EXEC = acec
 
-LIBS = -lgmp -Iopenf4 -Llib -lopenf4
+LIBS = -lgmp -Iopenf4 -Llib -lopenf4 -lcadical -LhCaD_V2/build/
 
-CXXFLAGS=-O3 -std=c++17
+CXXFLAGS=-O3 -IhCaD_V2 -std=c++17
 
 $(EXEC): $(OBJS)
 	$(CXX) -o $@ $^ $(CXXFLAGS) $(LIBS)
diff --git a/mathic b/mathic
deleted file mode 160000
index 66b5d74..0000000
--- a/mathic
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 66b5d74f8417459414cbf3753cfa9a0128483cbd
diff --git a/monomial.cpp b/monomial.cpp
new file mode 100644
index 0000000..267226f
--- /dev/null
+++ b/monomial.cpp
@@ -0,0 +1,88 @@
+/*------------------------------------------------------------------------*/
+/*! \file monomial.cpp
+    \brief contains the class Monomial and further functions to
+    manipulate monomials
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#include "monomial.h"
+/*------------------------------------------------------------------------*/
+
+Monomial::Monomial(mpz_t _c, Term * _t): ref(1) {
+  mpz_init_set(coeff, _c);
+  if (mpz_sgn(_c) == 0) term = 0;
+  else  term = _t;
+}
+
+/*------------------------------------------------------------------------*/
+
+Monomial * Monomial::copy() {
+  Monomial * m = this;
+  if (!m) return 0;
+  assert(ref > 0);
+
+  ++ref;
+  assert(ref);
+  return this;
+}
+
+/*------------------------------------------------------------------------*/
+
+Monomial::~Monomial() {
+  assert(ref == 0);
+
+  mpz_clear(coeff);
+  deallocate_term(term);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Monomial::print(FILE * file, bool lm) const {
+  int sign = mpz_sgn(coeff);
+  if (!sign) return;
+  else if (!lm && sign > 0) fputc_unlocked('+', file);
+
+  if (term) {
+    if (mpz_cmp_si(coeff, -1) == 0) { fputc_unlocked('-', file);
+    } else if (mpz_cmp_si(coeff, 1) != 0) {
+      mpz_out_str(file, 10, coeff);
+      fputc_unlocked('*', file);
+    } term->print(file);
+  }
+  else  mpz_out_str(file, 10, coeff);
+}
+
+/*------------------------------------------------------------------------*/
+
+Monomial * multiply_monomial(const Monomial * m1, const Monomial *m2) {
+  assert(m1);
+  assert(m2);
+
+  mpz_t coeff;
+  mpz_init(coeff);
+  mpz_mul(coeff, m1->coeff, m2->coeff);
+
+  Term * t;
+  if (m1->get_term() && m2->get_term())
+    t = multiply_term(m1->get_term(), m2->get_term());
+  else if (m2->get_term()) t = m2->get_term_copy();
+  else if (m1->get_term()) t = m1->get_term_copy();
+  else
+    t = 0;
+
+  Monomial * mon = new Monomial(coeff, t);
+
+  mpz_clear(coeff);
+  return mon;
+}
+
+/*------------------------------------------------------------------------*/
+
+void deallocate_monomial(Monomial * m) {
+  assert(m->get_ref() > 0);
+  if (m->dec_ref() > 0) return;
+
+  delete(m);
+}
diff --git a/monomial.h b/monomial.h
new file mode 100644
index 0000000..3636093
--- /dev/null
+++ b/monomial.h
@@ -0,0 +1,109 @@
+/*------------------------------------------------------------------------*/
+/*! \file monomial.h
+    \brief contains the class Monomial and further functions to
+    manipulate monomials
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#ifndef AMULET2_SRC_MONOMIAL_H_
+#define AMULET2_SRC_MONOMIAL_H_
+/*------------------------------------------------------------------------*/
+#include <gmp.h>
+
+#include "term.h"
+/*------------------------------------------------------------------------*/
+
+/** \class Monomial
+    This class is used to represent monomials in a polynomial.
+    A monomial consist of a coefficient and a term.
+*/
+
+class Monomial {
+  // / Term*
+  Term * term;
+
+  // / reference counter
+  unsigned ref;
+
+ public:
+  // / Coefficient
+  mpz_t coeff;
+
+  /** Constructor
+
+      @param c mpz_t coefficient
+      @param t Term*
+  */
+  Monomial(mpz_t _c, Term * _t);
+
+  /** Getter for member term
+
+      @return Term*
+  */
+  Term * get_term()       const {return term;}
+
+  /** Getter for member term, calls copy routine of Term
+
+      @return a copy of Term* term
+  */
+  Term * get_term_copy()  const {return term->copy();}
+
+  /** Returns the size fo the term
+
+      @return unsigned, the size of the term
+  */
+  unsigned get_term_size() const {return term->size();}
+
+  /** Decreases the reference counter
+
+      @return the decreases reference counter
+  */
+  unsigned dec_ref()             {return --ref;}
+
+  /** Getter for the reference counter
+
+      @return member ref
+  */
+  unsigned get_ref()       const {return ref;}
+
+  /**
+  Copy routine
+
+  @return Same monomial with increased reference counter
+  */
+  Monomial * copy();
+
+  /**
+  Printing routine
+
+  @param file Output file
+  @param lm bool indicating whether we print a leading monomial
+  */
+  void print(FILE * file, bool lm = 0) const;
+
+  /** Destructor */
+  ~Monomial();
+};
+/*------------------------------------------------------------------------*/
+
+/**
+  Multiplies two monomials
+
+  @param m1 Monomial*
+  @param m2 Monomial*
+
+  @return Product of m1*m2
+*/
+Monomial * multiply_monomial(const Monomial * m1, const Monomial *m2);
+
+/**
+  Wrapper for deconstructor, reduces the references of m until 0.
+  Then deconstructor is called.
+
+  @param m Monomial*
+*/
+void deallocate_monomial(Monomial * m);
+
+#endif  // AMULET2_SRC_MONOMIAL_H_
diff --git a/openf4 b/openf4
deleted file mode 160000
index 7155c6e..0000000
--- a/openf4
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 7155c6ec4e5f776e0e12202716dc7da58469e77b
diff --git a/polynomial.cpp b/polynomial.cpp
new file mode 100644
index 0000000..5d0d3d8
--- /dev/null
+++ b/polynomial.cpp
@@ -0,0 +1,390 @@
+/*------------------------------------------------------------------------*/
+/*! \file polynomial.cpp
+    \brief contains arithmetic operations for polynomials
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#include "polynomial.h"
+/*------------------------------------------------------------------------*/
+
+Polynomial::Polynomial() {}
+Polynomial::Polynomial (Monomial ** m, size_t len):mon(m), num_mon(len) {}
+
+/*------------------------------------------------------------------------*/
+
+Polynomial * Polynomial::copy() const {
+
+  for (size_t i = 0 ; i < size(); i++) {
+    Monomial * m = get_mon(i);
+    push_mstack_end(m->copy());
+  }
+  Polynomial * out = build_poly();
+  out->set_idx(idx);
+  return out;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Polynomial::print(FILE * file, bool end) const {
+  if (size() == 0) { fputs_unlocked("0", file);
+  } else {
+    for (size_t i = 0 ; i < size(); i++) {
+      Monomial * m = get_mon(i);
+      if (i == 0) m->print(file, 1);
+      else
+        m->print(file, 0);
+    }
+  }
+  if (end) fputs(";\n", file);
+}
+
+/*------------------------------------------------------------------------*/
+
+Polynomial::~Polynomial() {
+  for (size_t i = 0 ; i < size(); i++) {
+    Monomial * m = get_mon(i);
+    deallocate_monomial(m);
+  }
+  delete[]mon;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Polynomial::is_constant_zero_poly() const {
+  return size() == 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Polynomial::is_constant_one_poly() const {
+  if (size() != 1) return 0;
+
+  Monomial * m = get_mon(0);
+  if (m->get_term()) return 0;
+  if (mpz_cmp_si(m->coeff, 1) != 0) return 0;
+
+  return 1;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Polynomial::min_term_size() const {
+    int len = INT_MAX;
+
+    for (size_t i = 0 ; i < size(); i++) {
+      Monomial * m = get_mon(i);
+
+      int tlen = 0;
+      if (m->get_term()) tlen=m->get_term_size();
+      if (tlen < len) len = tlen;
+    }
+    return len;
+}
+
+/*------------------------------------------------------------------------*/
+// Local variables
+static size_t size_mstack;  // /< size of mstack
+static size_t num_mstack = 0;  // /< number of elements in mstack
+static Monomial ** mstack;  // /< Monomial** used for building poly
+/*------------------------------------------------------------------------*/
+
+void enlarge_mstack() {
+  size_t new_size_mstack = size_mstack ? 2*size_mstack : 1;
+
+  Monomial** newArr = new Monomial*[new_size_mstack];
+  memcpy( newArr, mstack, size_mstack * sizeof(Monomial*) );
+  delete [] mstack;
+  mstack = newArr;
+  size_mstack = new_size_mstack;
+}
+
+/*------------------------------------------------------------------------*/
+
+void clear_mstack() {
+  num_mstack = 0;
+  size_mstack = 0;
+  mstack = 0;}
+
+/*------------------------------------------------------------------------*/
+
+void deallocate_mstack() { delete[](mstack); }
+
+/*------------------------------------------------------------------------*/
+
+bool mstack_is_empty() { return num_mstack == 0;}
+
+/*------------------------------------------------------------------------*/
+void push_mstack_end(Monomial *m) {
+  if (size_mstack == num_mstack) enlarge_mstack();
+
+  assert(m);
+  if (mpz_sgn(m->coeff) == 0) {
+    deallocate_monomial(m);
+    return;
+  }
+
+  mstack[num_mstack++] = m;
+}
+
+/*------------------------------------------------------------------------*/
+
+void push_mstack(Monomial *m) {
+  assert(m);
+  if (mpz_sgn(m->coeff) == 0) {
+    deallocate_monomial(m);
+    return;
+  }
+
+  if (size_mstack == num_mstack) enlarge_mstack();
+  if (num_mstack == 0) {
+    mstack[num_mstack++] = m;
+    return;
+  }
+
+  if (!m->get_term()) {
+    Monomial * tmp = mstack[num_mstack-1];
+
+    if (tmp->get_term()) { mstack[num_mstack++] = m;
+    } else {
+      mpz_t coeff;
+      mpz_init(coeff);
+      mpz_add(coeff, tmp->coeff, m->coeff);
+      deallocate_monomial(m);
+      deallocate_monomial(tmp);
+
+      if (mpz_sgn(coeff) != 0)
+        mstack[num_mstack-1] = new Monomial(coeff, 0);
+      else
+        --num_mstack;
+
+      mpz_clear(coeff);
+    }
+  } else {
+    assert(num_mstack > 0);
+    int i = num_mstack-1;
+    int cmp = -1;
+    Monomial * tmp = 0;
+
+    while (i >= 0) {
+      tmp = mstack[i];
+      cmp = tmp->get_term()->cmp(m->get_term());
+
+      if (cmp >= 0) break;
+      i--;
+    }
+
+    if (cmp == 0) {
+      mpz_t coeff;
+      mpz_init(coeff);
+      mpz_add(coeff, tmp->coeff, m->coeff);
+
+      if (mpz_sgn(coeff) == 0) {
+        for (unsigned j = i; j < num_mstack-1; j++)
+          mstack[j] = mstack[j+1];
+        num_mstack--;
+      } else {
+        mstack[i] = new Monomial(coeff, m->get_term_copy());
+      }
+      deallocate_monomial(m);
+      deallocate_monomial(tmp);
+      mpz_clear(coeff);
+    } else {
+      for (int j = num_mstack; j > i+1; j--)
+      mstack[j] = mstack[j-1];
+      mstack[i+1] = m;
+      num_mstack++;
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+Polynomial * build_poly() {
+  Polynomial * res = new Polynomial(mstack, num_mstack);
+  clear_mstack();
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+Polynomial * add_poly(const Polynomial * p1, const Polynomial * p2) {
+  assert(p1);
+  assert(p2);
+
+  size_t i = 0, j= 0;
+
+  Monomial * m1 = p1->get_mon(i);
+  Monomial * m2 = p2->get_mon(j);
+  mpz_t coeff;
+  mpz_init(coeff);
+
+  while (i < p1->size() && j < p2->size()) {
+    if (!m1->get_term() || !m2->get_term()) {
+      if (!m1->get_term() && !m2->get_term()) {
+        mpz_add(coeff, m1->coeff, m2->coeff);
+        if (mpz_sgn(coeff) != 0) {
+          Monomial * m = new Monomial(coeff, 0);
+          push_mstack_end(m);
+        }
+        m1 = p1->get_mon(++i);
+        m2 = p2->get_mon(++j);
+
+      } else if (!m1->get_term()) {
+        push_mstack_end(m2->copy());
+        m2 = p2->get_mon(++j);
+      } else {
+        push_mstack_end(m1->copy());
+        m1 = p1->get_mon(++i);
+      }
+    } else {
+      int cmp = m1->get_term()->cmp(m2->get_term());
+      if (cmp == 1) {
+        push_mstack_end(m1->copy());
+        m1 = p1->get_mon(++i);
+      } else if (cmp == -1) {
+        push_mstack_end(m2->copy());
+        m2 = p2->get_mon(++j);
+      } else {
+        mpz_add(coeff, m1->coeff, m2->coeff);
+        if (mpz_sgn(coeff) != 0) {
+          Monomial * m = new Monomial(coeff, m1->get_term_copy());
+          push_mstack_end(m);
+        }
+        m1 = p1->get_mon(++i);
+        m2 = p2->get_mon(++j);
+      }
+    }
+  }
+  mpz_clear(coeff);
+
+  while (i < p1->size()) {
+    push_mstack_end(m1->copy());
+    m1 = p1->get_mon(++i);
+  }
+  while (j < p2->size()) {
+    push_mstack_end(m2->copy());
+    m2 = p2->get_mon(++j);
+  }
+
+  Polynomial * p = build_poly();
+  return p;
+}
+
+
+/*------------------------------------------------------------------------*/
+
+Polynomial * multiply_poly(const Polynomial * p1, const Polynomial * p2) {
+  if(!p1 || !p2) return 0;
+  mpz_t coeff;
+  mpz_init(coeff);
+  Term * t;
+  for (size_t i = 0 ; i < p1->size(); i++) {
+    Monomial * m1 = p1->get_mon(i);
+    for (size_t j = 0 ; j < p2->size(); j++) {
+      Monomial * m2 = p2->get_mon(j);
+      if (mpz_cmp_si(m1->coeff, -1) == 0 ) mpz_neg(coeff, m2->coeff);
+      else if (mpz_cmp_si(m2->coeff, -1) == 0 ) mpz_neg(coeff, m1->coeff);
+      else
+        mpz_mul(coeff, m1->coeff, m2->coeff);
+
+      if (m1->get_term() && m2->get_term())
+        t = multiply_term(m1->get_term(), m2->get_term());
+      else if (m2->get_term())
+        t = m2->get_term_copy();
+      else if (m1->get_term())
+        t = m1->get_term_copy();
+      else
+        t = 0;
+      push_mstack(new Monomial(coeff, t));
+    }
+  }
+  Polynomial * p = build_poly();
+  mpz_clear(coeff);
+  return p;
+}
+
+/*------------------------------------------------------------------------*/
+
+Polynomial * multiply_poly_with_constant(const Polynomial *p1, mpz_t c) {
+  if (mpz_sgn(c) == 0) return 0;
+  mpz_t coeff;
+  mpz_init(coeff);
+
+  for (size_t i = 0 ; i < p1->size(); i++) {
+    Monomial * m = p1->get_mon(i);
+    mpz_mul(coeff, m->coeff, c);
+    if (m->get_term())
+      push_mstack_end(new Monomial(coeff, m->get_term_copy()));
+    else
+      push_mstack_end(new Monomial(coeff, 0));
+  }
+  Polynomial * tmp = build_poly();
+  mpz_clear(coeff);
+  return tmp;
+}
+
+/*------------------------------------------------------------------------*/
+
+Polynomial * divide_by_term(const Polynomial * p1, const Term * t) {
+  assert(t->size() == 1);
+  const Var * v = t->get_var();
+
+  for (size_t i = 0 ; i < p1->size(); i++) {
+    Monomial * lm_tmp = p1->get_mon(i);
+
+    if (!lm_tmp->get_term()) continue;
+    if (lm_tmp->get_term()->cmp(t) == -1) break;
+
+    if (lm_tmp->get_term()->contains(v)) {
+      Term * t_rem = remainder(lm_tmp->get_term(), v);
+      if (t_rem) { push_mstack_end(new Monomial(lm_tmp->coeff, t_rem->copy()));
+      } else {
+        push_mstack_end(new Monomial(lm_tmp->coeff, 0));
+        break;
+      }
+    }
+  }
+  Polynomial * p = build_poly();
+  return p;
+}
+
+
+/*------------------------------------------------------------------------*/
+mpz_t one;
+mpz_t minus_one;
+mpz_t two;
+mpz_t minus_two;
+mpz_t base;
+mpz_t mod_coeff;
+mpz_t four;
+mpz_t minus_four;
+
+/*------------------------------------------------------------------------*/
+
+void init_mpz(unsigned exp) {
+  mpz_init_set_ui(one, 1);
+  mpz_init_set_si(minus_one, -1);
+  mpz_init_set_ui(two, 2);
+  mpz_init_set_si(minus_two, -2);
+  mpz_init_set_ui(four, 4);
+  mpz_init_set_si(minus_four, -4);
+  mpz_init_set_ui(base, 2);
+
+  mpz_init(mod_coeff);
+  mpz_pow_ui(mod_coeff, base, exp);
+}
+
+/*------------------------------------------------------------------------*/
+
+void clear_mpz() {
+  mpz_clear(one);
+  mpz_clear(minus_one);
+  mpz_clear(base);
+  mpz_clear(mod_coeff);
+  mpz_clear(two);
+  mpz_clear(minus_two);
+}
+
+/*------------------------------------------------------------------------*/
diff --git a/polynomial.h b/polynomial.h
new file mode 100644
index 0000000..dab2390
--- /dev/null
+++ b/polynomial.h
@@ -0,0 +1,245 @@
+/*------------------------------------------------------------------------*/
+/*! \file polynomial.h
+    \brief contains arithmetic operations for polynomials
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#ifndef AMULET2_SRC_POLYNOMIAL_H_
+#define AMULET2_SRC_POLYNOMIAL_H_
+/*------------------------------------------------------------------------*/
+#include <list>
+#include <deque>
+#include <cstring>
+
+#include "monomial.h"
+/*------------------------------------------------------------------------*/
+
+/** \class Polynomial
+    This class is used to polynomials.
+*/
+class Polynomial {
+  int idx;  // /< index as used in pac proofs
+
+  int level = 1;  // /< level of polynomials needed for certificates
+
+  Monomial ** mon;  // /< sorted deque of monomials
+
+  size_t num_mon = 0;
+
+ public:
+  /** Constructor */
+  Polynomial();
+
+  Polynomial (Monomial ** m, size_t len);
+
+  /** Getter for member idx
+
+      @return integer
+  */
+  int get_idx() const {return idx;}
+
+  /**
+      Setter for idx
+
+      @param idx_ integer
+  */
+  void set_idx(int idx_) {idx = idx_;}
+
+  /** Getter for member level
+
+      @return integer
+  */
+  int get_level() const {return level;}
+
+  /**
+      Setter for level
+
+      @param level_ integer
+  */
+  void set_level(int level_) {level = level_;}
+
+  Monomial * get_mon(size_t i) const {
+     if(i < num_mon) return mon[i];
+     else return 0;
+   }
+
+   size_t size() const { return num_mon;}
+
+  /** Returns the leading term
+
+      @return Term*
+  */
+  Term * get_lt() const {return mon[0]->get_term();}
+
+  /**
+      Copy routine
+
+      @return A hard copy of the current polynomial
+  */
+  Polynomial * copy() const;
+
+  /**
+      Printing routine
+
+      @param file Output file
+      @param end if true we print trailing ";"
+  */
+  void print(FILE * file, bool end = 1) const;
+
+  /** Destructor */
+  ~Polynomial();
+
+
+  /**
+      Returns whether the polynomial is the constant zero polynomial
+
+      @return bool
+  */
+  bool is_constant_zero_poly() const;
+
+  /**
+      Returns whether the polynomial is the constant one polynomial
+
+      @return bool
+  */
+  bool is_constant_one_poly() const;
+
+  /**
+      Returns the size of the smallest term
+
+      @return integer
+  */
+  int min_term_size() const;
+};
+/*------------------------------------------------------------------------*/
+// Polynomials are generated using a sorted array "mstack"
+
+/**
+    Enlarges the allocated size of mstack
+*/
+void enlarge_mstack();
+
+/**
+    Sets the number of elements in the stack to 0
+*/
+void clear_mstack();
+
+/**
+    Deallocates mstack
+*/
+void deallocate_mstack();
+
+/**
+    Checks whether mstack is empty
+
+    @return true if mstack is empty
+*/
+bool mstack_is_empty();
+
+/**
+    Pushes a monomial to the end of the stack
+
+    @param t monomial to be added to the mstack
+*/
+void push_mstack_end(Monomial *t);
+
+/**
+    Pushes a monomial to the stack such that mstack remains sorted
+
+    @param t monomial to be added to the mstack
+*/
+void push_mstack(Monomial *t);
+
+
+/**
+    Generates a polynomial from mstack and clears mstack
+
+    @return Polynomial*
+*/
+Polynomial * build_poly();
+
+
+/*------------------------------------------------------------------------*/
+
+/**
+    Add two polynomials p1+p2
+
+    @param p1 Polynomial*
+    @param p2 Polynomial*
+
+    @return Polynomial*, sum of p1+p2
+*/
+Polynomial * add_poly(const Polynomial *p1, const Polynomial *p2);
+
+/**
+    Multiplies two polynomials p1*p2
+
+    @param p1 Polynomial*
+    @param p2 Polynomial*
+
+    @return Polynomial*, product of p1*p2
+*/
+Polynomial * multiply_poly(const Polynomial *p1, const Polynomial *p2);
+
+/**
+    Multiplies a polynomial p1 with a constant c
+
+    @param p1: Polynomial*
+    @param c:  mpz_t object
+
+    @return Polynomial*, product of c*p1
+*/
+Polynomial * multiply_poly_with_constant(const Polynomial *p1, mpz_t c);
+
+
+/**
+    Returns the quotient of dividing a polynomial p1 by a term t
+
+    @param p1 Polynomial*
+    @param t  Term *
+
+    @return Polynomial defining the quotient of p1/t
+*/
+Polynomial * divide_by_term(const Polynomial * p1, const Term * t);
+
+
+/*---------------------------------------------------------------------------*/
+// / gmp for 1
+extern mpz_t one;
+
+// / gmp for -1
+extern mpz_t minus_one;
+
+// / gmp for 2
+extern mpz_t two;
+
+// / gmp for -2
+extern mpz_t minus_two;
+
+// / gmp for 4
+extern mpz_t four;
+
+// / gmp for -4
+extern mpz_t minus_four;
+
+// / gmp for 2
+extern mpz_t base;
+
+// / gmp for 2^NN
+extern mpz_t mod_coeff;
+/*---------------------------------------------------------------------------*/
+/**
+    Initializes all global gmp objects
+
+    @param exp unsigned exponent for mod coeff
+*/
+void init_mpz(unsigned exp);
+
+/**
+    Clears all globally allocated gmp objects
+*/
+void clear_mpz();
+
+#endif  // AMULET2_SRC_POLYNOMIAL_H_
diff --git a/result.smt b/result.smt
new file mode 100644
index 0000000..ef54b64
--- /dev/null
+++ b/result.smt
@@ -0,0 +1,428 @@
+-A26+A23*A7;
+-A27+A8*A3;
+-A30+2*A26*A27-A26-A27+1;
+-A31+A22*A9;
+-A34-2*A30*A31+A30+A31;
+-A35+A23*A8;
+-A36+A9*A3;
+-A38+A22*A19;
+-A46+2*A43*A34-A43-A34+1;
+-A47+A24*A19;
+-A48+A21*A14;
+-A51+2*A47*A48-A47-A48+1;
+-A52+A16*A10;
+-A55-2*A51*A52+A51+A52;
+-A58+2*A46*A55-A46-A55+1;
+A61+2*A43+A35+A38+A36-3;
+-A62+A23*A9;
+-A63+A19*A3;
+-A65+A22*A21;
+-A72+A24*A21;
+-A73+A14*A10;
+-A77+A17*A16;
+2*A91+A80+A72+A77+A73-3;
+-A88+2*A85*A58-A85-A58+1;
+-A92+A17*A13;
+-A93+A15*A2;
+-A96+2*A92*A93-A92-A93+1;
+-A97+A11*A4;
+-A100-2*A96*A97+A96+A97;
+-A103+2*A91*A100-A91-A100+1;
+-A104+A15*A13;
+-A105+A11*A2;
+-A107+A5*A4;
+-A115+2*A103*A112-A103-A112+1;
+-A118+2*A88*A115-A88-A115+1;
+A121+2*A85-A80-A70-A61;
+A124+2*A70+A62+A65+A63-3;
+-A125+A23*A19;
+-A126+A21*A3;
+-A128+A22*A10;
+-A135+A24*A10;
+-A136+A17*A14;
+-A140+A16*A15;
+2*A152+A143+A135+A136+A140-3;
+A155+2*A112+A104+A105+A107-3;
+-A159+A13*A11;
+-A160+A5*A2;
+-A162+A12*A4;
+2*A181+A170-A152-A155-A167;
+-A178+2*A175*A118-A175-A118+1;
+-A182+A5*A1;
+-A183+A12*A6;
+-A186+2*A183*A182-A183-A182+1;
+-A189+2*A181*A186-A181-A186+1;
+-A192+2*A178*A189-A178-A189+1;
+A195+2*A175-A170-A148-A121;
+A198+2*A148-A143-A133-A124;
+A201+2*A133+A125+A128+A126-3;
+-A202+A23*A21;
+-A203+A10*A3;
+-A205+A22*A17;
+-A212+A24*A17;
+-A213+A15*A14;
+-A217+A16*A11;
+2*A229+A220+A212+A217+A213-3;
+A232+2*A167+A159+A162+A160-3;
+-A236+A13*A5;
+-A237+A12*A2;
+2*A251+A241-A229-A232+A238-1;
+-A248+A12*A1;
+A254-2*A263-A251+A248;
+-A262+2*A259*A192-A259-A192+1;
+-A266-2*A262*A263+A262+A263;
+A269+2*A259-A246-A195-A254;
+A272+2*A246-A241-A225-A198;
+A275+2*A225-A220-A210-A201;
+A278+2*A210+A202+A205+A203-3;
+-A279+A23*A10;
+-A280+A17*A3;
+-A282+A22*A15;
+-A289+A24*A15;
+-A290+A14*A11;
+-A294+A16*A5;
+2*A309+A297+A289+A294+A290-3;
+A306-2*A238+A236+A237-1;
+A312-2*A319-A309-A306+1;
+-A328-2*A266*A325+A266+A325;
+A331-2*A325-A324-A269+1;
+A334+2*A324-A317-A272+A319-1;
+A337+2*A317-A302-A275-A312;
+A340+2*A302-A297-A287-A278;
+A343+2*A287+A279+A282+A280-3;
+-A344+A23*A17;
+-A345+A15*A3;
+-A347+A22*A11;
+-A354+A24*A11;
+-A355+A14*A5;
+-A359+A16*A12;
+2*A372+A362+A354+A359+A355-3;
+-A369+A13*A12;
+A375-2*A382-A372+A369;
+-A392-2*A328*A389+A328+A389;
+A395-2*A389-A331+A388;
+A398-2*A388-A387-A334+1;
+A401+2*A387-A380-A337+A382-1;
+A404+2*A380-A367-A340-A375;
+A407+2*A367-A362-A352-A343;
+A410+2*A352+A344+A347+A345-3;
+-A411+A23*A15;
+-A412+A11*A3;
+-A414+A22*A5;
+-A421+A24*A5;
+-A422+A14*A12;
+A425-2*A432+A421+A422-1;
+-A444-2*A392*A441+A392+A441;
+A447-2*A441-A395+A440;
+A450-2*A440-A398+A439;
+A453-2*A439-A401+A438;
+A456-2*A438-A437-A404+1;
+A459+2*A437-A430-A407+A432-1;
+A462+2*A430-A419-A410-A425;
+A465+2*A419+A411+A414+A412-3;
+-A466+A23*A11;
+-A467+A5*A3;
+-A469+A22*A12;
+-A476+A24*A12;
+A490-2*A487-A447+A486;
+A493-2*A486-A450+A485;
+A496-2*A485-A453+A484;
+A499-2*A484-A456+A483;
+A502-2*A483-A459+A482;
+A505-2*A482-A481-A462+1;
+A508+2*A481-A474-A465+A476-1;
+A511+2*A474+A466+A469+A467-3;
+-A512+A23*A5;
+-A513+A12*A3;
+-A514+A512*A513;
+-A515-A511*A514+A514;
+-A516-A508*A515+A515;
+-A517-A505*A516+A516;
+-A518-A502*A517+A517;
+-A519-A499*A518+A518;
+-A520-A496*A519+A519;
+-A521-A493*A520+A520;
+-A522-A490*A521+A521;
+-A523+A522*A487-A522-A487+1;
+-A526+2*A523*A444-A523-A444+1;
+-A527+A21*A10;
+-A529-2*A528-A21-A10+2;
+-A530-A529*A22+A22;
+-A531+A529*A24;
+-A532+A531*A530-A531-A530+1;
+-A533-A527*A19+A19;
+-A534-A532*A533+A532;
+-A535+A528*A19-A528-A19+1;
+-A536+A532*A535-A532-A535+1;
+-A537+A536*A534-A536-A534+1;
+-A538+A19*A9;
+-A540-2*A539-A19-A9+2;
+-A541-A540*A23+A23;
+-A542+A540*A3;
+-A543+A542*A541-A542-A541+1;
+-A544-A538*A8+A8;
+-A545-A543*A544+A543;
+-A546+A539*A8-A539-A8+1;
+-A547+A543*A546-A543-A546+1;
+-A548+A547*A545-A547-A545+1;
+-A551+2*A537*A548-A537-A548+1;
+-A552+A17*A15;
+-A554-2*A553-A17-A15+2;
+-A555-A554*A14+A14;
+-A556+A554*A16;
+-A557+A556*A555-A556-A555+1;
+-A558-A552*A10+A10;
+-A559-A557*A558+A557;
+-A560+A553*A10-A553-A10+1;
+-A561+A557*A560-A557-A560+1;
+-A562+A561*A559-A561-A559+1;
+-A565-2*A551*A562+A551+A562;
+-A566-A13*A12+A13;
+-A567+A566*A237-A566-A237+1;
+-A568-A567*A5+A567;
+-A569-A12*A5+A12;
+-A570+A567*A569-A567-A569+1;
+-A571+A570*A568-A570-A568+1;
+-A572-A16*A12+A16;
+-A573+A572*A369-A572-A369+1;
+-A574-A573*A5+A573;
+-A575+A573*A569-A573-A569+1;
+-A576+A575*A574-A575-A574+1;
+-A579-A554*A24+A24;
+-A580+A554*A14;
+-A581+A580*A579-A580-A579+1;
+-A582-A581*A558+A581;
+-A583+A581*A560-A581-A560+1;
+-A584+A583*A582-A583-A582+1;
+-A586+A11*A5;
+-A588-2*A587-A11-A5+2;
+-A589-A588*A16+A16;
+-A590+A588*A13;
+-A591+A590*A589-A590-A589+1;
+-A592-A586*A15+A15;
+-A593-A591*A592+A591;
+-A594+A587*A15-A587-A15+1;
+-A595+A591*A594-A591-A594+1;
+-A596+A595*A593-A595-A593+1;
+-A600+2*A584*A578*A596-A584*A578-A584*A596-A578*A596+1;
+-A602-A12*A4+A4;
+-A603+A602*A248-A602-A248+1;
+-A604-A603*A5+A603;
+-A605+A603*A569-A603-A569+1;
+-A606+A605*A604-A605-A604+1;
+-A607-A12*A2+A2;
+-A608+A607*A162-A607-A162+1;
+-A609-A608*A5+A608;
+-A610+A608*A569-A608-A569+1;
+-A611+A610*A609-A610-A609+1;
+A615-2*A682+A612+A606-1;
+-A616-A588*A13+A13;
+-A617+A588*A2;
+-A618+A617*A616-A617-A616+1;
+-A619-A618*A592+A618;
+-A620+A618*A594-A618-A594+1;
+-A621+A620*A619-A620-A619+1;
+-A624-2*A615*A621+A615+A621;
+A627-2*A612+A611+A544-1;
+-A628-A529*A3+A3;
+-A629+A529*A22;
+-A630+A629*A628-A629-A628+1;
+-A631-A630*A533+A630;
+-A632+A630*A535-A630-A535+1;
+-A633+A632*A631-A632-A631+1;
+-A635+A540*A23;
+-A636+A635*A544-A635-A544+1;
+-A637-A635*A546+A635;
+-A638+A637*A636-A637-A636+1;
+-A642-2*A633*A627*A638+A633*A627+A633*A638-A633+A627*A638-A638+1;
+-A645+2*A642*A624-A642-A624+1;
+-A649-2*A645*A565*A600+A645*A565+A645*A600+A565*A600;
+-A650-A588*A2+A2;
+-A651+A588*A4;
+-A652+A651*A650-A651-A650+1;
+-A653-A652*A592+A652;
+-A654+A652*A594-A652-A594+1;
+-A655+A654*A653-A654-A653+1;
+-A656-A529*A24+A24;
+-A657+A529*A14;
+-A658+A657*A656-A657-A656+1;
+-A659-A658*A533+A658;
+-A660+A658*A535-A658-A535+1;
+-A661+A660*A659-A660-A659+1;
+-A664+2*A661*A655-A661-A655+1;
+-A665-A554*A16+A16;
+-A666+A554*A13;
+-A667+A666*A665-A666-A665+1;
+-A668-A667*A558+A667;
+-A669+A667*A560-A667-A560+1;
+-A670+A669*A668-A669-A668+1;
+-A673-2*A664*A670+A664+A670;
+-A678+2*A642*A615*A621-A642*A615-A642*A621+A642-A615*A621+A615;
+-A681+2*A678*A673-A678-A673+1;
+-A687+2*A537*A548*A562-A537*A548-A537*A562-A548*A562+1;
+-A690-2*A687*A682+A687+A682;
+-A691+A8*A7;
+-A692-A691*A25+A25;
+-A693-A12*A1+A1;
+-A694+A693*A183-A693-A183+1;
+-A695-A694*A5+A694;
+-A696+A694*A569-A694-A569+1;
+-A697+A696*A695-A696-A695+1;
+-A700+2*A697*A692-A697-A692+1;
+-A701-A540*A3+A3;
+-A702+A540*A22;
+-A703+A702*A701-A702-A701+1;
+-A704-A703*A544+A703;
+-A705+A703*A546-A703-A546+1;
+-A706+A705*A704-A705-A704+1;
+-A709-2*A706*A700+A706+A700;
+-A711-2*A710-A8-A7+2;
+-A712+A711*A23;
+-A713+A712*A692-A712-A692+1;
+-A714+A710*A25-A710-A25+1;
+-A715-A712*A714+A712;
+-A716+A715*A713-A715-A713+1;
+-A719-2*A709*A716+A709+A716;
+-A722+2*A690*A719-A690-A719+1;
+-A725+2*A681*A722-A681-A722+1;
+-A728+2*A725*A649-A725-A649+1;
+-A729-A588*A14+A14;
+-A730+A588*A16;
+-A731+A730*A729-A730-A729+1;
+-A732-A731*A592+A731;
+-A733+A731*A594-A731-A594+1;
+-A734+A733*A732-A733-A732+1;
+-A735-A529*A23+A23;
+-A736+A529*A3;
+-A737+A736*A735-A736-A735+1;
+-A738-A737*A533+A737;
+-A739+A737*A535-A737-A535+1;
+-A740+A739*A738-A739-A738+1;
+-A742-A554*A22+A22;
+-A743+A554*A24;
+-A744+A743*A742-A743-A742+1;
+-A745-A744*A558+A744;
+-A746+A744*A560-A744-A560+1;
+-A747+A746*A745-A746-A745+1;
+-A751+2*A740*A747*A734-A740*A747-A740*A734-A747*A734+1;
+-A754-2*A633*A627+A633+A627;
+-A757-2*A754*A638+A754+A638;
+-A761+2*A584*A578-A584-A578+1;
+-A764-2*A761*A596+A761+A596;
+-A768-2*A757*A764*A751+A757*A764+A757*A751+A764*A751;
+-A771+2*A565*A600-A565-A600+1;
+-A774+2*A771*A645-A771-A645+1;
+A778-2*A578+A577+A571-1;
+A781-2*A577+A576+A533-1;
+-A782-A554*A3+A3;
+-A783+A554*A22;
+-A784+A783*A782-A783-A782+1;
+-A785-A784*A558+A784;
+-A786+A784*A560-A784-A560+1;
+-A787+A786*A785-A786-A785+1;
+-A789+A529*A23;
+-A790+A789*A533-A789-A533+1;
+-A791-A789*A535+A789;
+-A792+A791*A790-A791-A790+1;
+-A796-2*A787*A781*A792+A787*A781+A787*A792-A787+A781*A792-A792+1;
+-A800+2*A740*A734-A740-A734+1;
+-A803-2*A800*A747+A800+A747;
+-A807-2*A803*A796*A778+A803*A796+A803*A778+A796*A778;
+-A810+2*A757*A751-A757-A751+1;
+-A813+2*A810*A764-A810-A764+1;
+-A815-A14*A12+A14;
+-A816+A359*A815-A359-A815+1;
+-A817-A816*A5+A816;
+-A818+A816*A569-A816-A569+1;
+-A819+A818*A817-A818-A817+1;
+-A820-A24*A12+A24;
+-A821+A820*A422-A820-A422+1;
+-A822-A821*A5+A821;
+-A823+A821*A569-A821-A569+1;
+-A824+A823*A822-A823-A822+1;
+-A827-A588*A24+A24;
+-A828+A588*A14;
+-A829+A828*A827-A828-A827+1;
+-A830-A829*A592+A829;
+-A831+A829*A594-A829-A594+1;
+-A832+A831*A830-A831-A830+1;
+-A836-2*A787*A781+A787+A781;
+-A839-2*A836*A792+A836+A792;
+-A843-2*A839*A826*A832+A839*A826+A839*A832+A826*A832-A826-A832+1;
+-A846+2*A796*A778-A796-A778+1;
+-A849+2*A846*A803-A846-A803+1;
+A853-2*A826+A825+A819-1;
+-A854-A554*A23+A23;
+-A855+A554*A3;
+-A856+A855*A854-A855-A854+1;
+-A857-A856*A558+A856;
+-A858+A856*A560-A856-A560+1;
+-A859+A858*A857-A858-A857+1;
+-A861-A588*A22+A22;
+-A862+A588*A24;
+-A863+A862*A861-A862-A861+1;
+-A864-A863*A592+A863;
+-A865+A863*A594-A863-A594+1;
+-A866+A865*A864-A865-A864+1;
+-A870-2*A853*A859*A866+A853*A859+A853*A866+A859*A866-A859-A866+1;
+-A873+2*A826*A832-A826-A832+1;
+-A876+2*A839*A873-A839-A873+1;
+A880-2*A825+A824+A558-1;
+-A881-A588*A3+A3;
+-A882+A588*A22;
+-A883+A882*A881-A882-A881+1;
+-A884-A883*A592+A883;
+-A885+A883*A594-A883-A594+1;
+-A886+A885*A884-A885-A884+1;
+-A888+A554*A23;
+-A889+A888*A558-A888-A558+1;
+-A890-A888*A560+A888;
+-A891+A890*A889-A890-A889+1;
+-A895-2*A880*A886*A891+A880*A886+A880*A891+A886*A891-A886-A891+1;
+-A898-2*A853*A859+A853+A859;
+-A901-2*A898*A866+A898+A866;
+-A903-A22*A12+A22;
+-A904+A476*A903-A476-A903+1;
+-A905-A904*A5+A904;
+-A906+A904*A569-A904-A569+1;
+-A907+A906*A905-A906-A905+1;
+-A908-A12*A3+A3;
+-A909+A469*A908-A469-A908+1;
+-A910-A909*A5+A909;
+-A911+A909*A569-A909-A569+1;
+-A912+A911*A910-A911-A910+1;
+-A917-2*A880*A886+A880+A886;
+-A920-2*A917*A891+A917+A891;
+A924-2*A914+A913+A907-1;
+-A925-A588*A23+A23;
+-A926+A588*A3;
+-A927+A926*A925-A926-A925+1;
+-A928-A927*A592+A927;
+-A929+A927*A594-A927-A594+1;
+-A930+A929*A928-A929-A928+1;
+A934-2*A913+A912+A592-1;
+-A935+A588*A23;
+-A936+A935*A592-A935-A592+1;
+-A937-A935*A594+A935;
+-A938+A937*A936-A937-A936+1;
+-A940-A23*A12+A23;
+-A941+A940*A513-A940-A513+1;
+-A942-A941*A5+A941;
+-A943+A941*A569-A941-A569+1;
+-A944+A943*A942-A943-A942+1;
+-A945+A23*A12;
+-A946+A945*A5-A945-A5+1;
+-A947-A945*A569+A945;
+-A948+A947*A946-A947-A946+1;
+-A949+A948*A5;
+-A950+A949*A944;
+-A954-2*A934*A950*A938+A934*A950+A934*A938+A950*A938-A950-A938+1;
+-A958+2*A954*A924*A930-A954*A924-A954*A930+A954-A924*A930+A924;
+-A962+2*A958*A920*A914-A958*A920-A958*A914+A958-A920*A914+A920;
+-A966-2*A962*A901*A895+A962*A901+A962*A895+A901*A895;
+-A970-2*A966*A876*A870+A966*A876+A966*A870+A876*A870;
+-A974-2*A970*A843*A849+A970*A843+A970*A849+A843*A849;
+-A978-2*A974*A813*A807+A974*A813+A974*A807+A813*A807;
+-A982-2*A978*A774*A768+A978*A774+A978*A768+A774*A768;
+-A985+2*A982*A728-A982-A728+1;
+-A988+2*A985*A526-A985-A526+1;
diff --git a/result.txt b/result.txt
index e69de29..4b43540 100644
--- a/result.txt
+++ b/result.txt
@@ -0,0 +1,56 @@
+  xor-relative:	-A19+2*A13*A12*A9*A7-A13*A12-A9*A7+1;
+  xor-relative:	-A23-2*A19*A10*A6+A19+A10*A6;
+  xor-relative:	-A30+2*A12*A9*A7*A6-A12*A9-A7*A6+1;
+  xor-relative:	-A35+2*A23*A31*A26-2*A23*A31-2*A23*A26+A23-A31*A26+A31+A26;
+  xor-relative:	-A40+2*A14*A5*A2*A1-A14*A1-A5*A2+1;
+  xor-relative:	-A44-2*A40*A4*A3+A40+A4*A3;
+  xor-relative:	-A47+2*A35*A44-A35-A44+1;
+  xor-relative:	-A50-2*A30*A10*A2+A30+A10*A2;
+  xor-relative:	-A57+2*A12*A7*A6*A2-A12*A6-A7*A2+1;
+  xor-relative:	-A65+2*A14*A5*A4*A1-A14*A5-A4*A1+1;
+  xor-relative:	-A69-2*A65*A11*A3+A65+A11*A3;
+  xor-relative:	-A72+2*A50*A58*A53-2*A50*A58-2*A50*A53+A50-A58*A53+A58+A53;
+  xor-relative:	-A77+2*A47*A73*A60-2*A47*A73-2*A47*A60+A47-A73*A60+A73+A60;
+  xor-relative:	-A84-2*A79*A78*A11*A8+A79*A78+2*A79*A11*A8-A79+2*A78*A11*A8-A78-A11*A8+1;
+  xor-relative:	-A87+2*A77*A84-A77-A84+1;
+  xor-relative:	-A90+2*A72*A69-A72-A69+1;
+  xor-relative:	-A93-2*A57*A14*A10+A57+A14*A10;
+  xor-relative:	-A100+2*A14*A12*A7*A2-A14*A7-A12*A2+1;
+  xor-relative:	-A108+2*A11*A5*A4*A1-A11*A1-A5*A4+1;
+  xor-relative:	-A111+2*A93*A101*A96-2*A93*A101-2*A93*A96+A93-A101*A96+A101+A96;
+  xor-relative:	-A118+2*A90*A112*A103-2*A90*A112-2*A90*A103+A90-A112*A103+A112+A103;
+  xor-relative:	-A123+2*A87*A119*A114-2*A87*A119-2*A87*A114+A87-A119*A114+A119+A114;
+  xor-relative:	-A126-2*A118*A105*A104+A118+A105*A104;
+  xor-relative:	-A129+2*A111*A108-A111-A108+1;
+  xor-relative:	-A132-2*A100*A10*A4+A100+A10*A4;
+  xor-relative:	-A139+2*A14*A12*A7*A4-A14*A12-A7*A4+1;
+  xor-relative:	-A146+2*A132*A140*A135-2*A132*A140-2*A132*A135+A132-A140*A135+A140+A135;
+  xor-relative:	-A153+2*A123*A126*A149-2*A123*A149+A123-A126*A149+A149;
+  xor-relative:	-A156-2*A126*A148*A129+2*A126*A148+2*A126*A129-A126+A148*A129-A148-A129+1;
+  xor-relative:	-A159+2*A129*A147*A142-2*A129*A147-2*A129*A142+A129-A147*A142+A147+A142;
+  xor-relative:	-A162-2*A146*A11*A5+A146+A11*A5;
+  xor-relative:	-A165-2*A139*A11*A10+A139+A11*A10;
+  xor-relative:	-A175+2*A153*A156*A171-2*A153*A171+A153-A156*A171+A171;
+  xor-relative:	-A182+2*A11*A10*A3*A2-A11*A3-A10*A2+1;
+  xor-relative:	-A185-2*A182*A14*A5+A182+A14*A5;
+  xor-relative:	-A189+2*A51*A52*A4*A1-A51*A52-A4*A1+1;
+  xor-relative:	-A192+2*A189*A30-A189-A30+1;
+  xor-relative:	-A199-2*A40*A24*A25+A40+A24*A25;
+  xor-relative:	-A207-2*A199*A202*A203+2*A199*A202-A199+A202*A203-A202+1;
+  xor-relative:	-A215-2*A210*A19*A211+2*A210*A19+A210*A211-A210-A19+1;
+  xor-relative:	-A218+2*A11*A10*A8*A6-A11*A8-A10*A6+1;
+  xor-relative:	-A221-2*A218*A4*A3+A218+A4*A3;
+  xor-relative:	-A224+2*A215*A221-A215-A221+1;
+  xor-relative:	-A227+2*A224*A207-A224-A207+1;
+  xor-relative:	-A230-2*A227*A194*A195+2*A227*A194-A227+A194*A195-A194+1;
+  xor-relative:	-A234+2*A14*A11*A10*A1-A14*A10-A11*A1+1;
+  xor-relative:	-A237-2*A234*A5*A4+A234+A5*A4;
+  xor-relative:	-A244-2*A185*A178*A115+2*A185*A178-A185+A178*A115-A178+1;
+  xor-relative:	-A247+2*A244*A192-A244-A192+1;
+  xor-relative:	-A257-2*A57*A95*A94+A57+A95*A94;
+  xor-relative:	-A260+2*A237*A257-A237-A257+1;
+  xor-relative:	-A264+2*A11*A10*A5*A4-A11*A5-A10*A4+1;
+  xor-relative:	-A267-2*A264*A136*A134+A264+A136*A134;
+  xor-relative:	-A272+2*A11*A10*A7*A4-A11*A10-A7*A4+1;
+  xor-relative:	-A291-2*A286*A287*A230+A286*A287+2*A286*A230-A286-A230+1;
+  xor-relative:	-A294+2*A175*A291-A175-A291+1;
diff --git a/smt.result b/smt.result
new file mode 100644
index 0000000..66f5305
--- /dev/null
+++ b/smt.result
@@ -0,0 +1,591 @@
+sat
+(
+  (define-fun A104 () Bool
+    true)
+  (define-fun A272 () Bool
+    false)
+  (define-fun A111 () Bool
+    true)
+  (define-fun A53 () Bool
+    false)
+  (define-fun A61 () Bool
+    true)
+  (define-fun A133 () Bool
+    false)
+  (define-fun A162 () Bool
+    true)
+  (define-fun A100 () Bool
+    false)
+  (define-fun A20 () Bool
+    false)
+  (define-fun A103 () Bool
+    false)
+  (define-fun A143 () Bool
+    true)
+  (define-fun A147 () Bool
+    true)
+  (define-fun A74 () Bool
+    true)
+  (define-fun A126 () Bool
+    true)
+  (define-fun A102 () Bool
+    true)
+  (define-fun A172 () Bool
+    false)
+  (define-fun A44 () Bool
+    false)
+  (define-fun A114 () Bool
+    false)
+  (define-fun A150 () Bool
+    false)
+  (define-fun A23 () Bool
+    false)
+  (define-fun A78 () Bool
+    true)
+  (define-fun A171 () Bool
+    false)
+  (define-fun A59 () Bool
+    true)
+  (define-fun A79 () Bool
+    false)
+  (define-fun A267 () Bool
+    false)
+  (define-fun A36 () Bool
+    false)
+  (define-fun A16 () Bool
+    true)
+  (define-fun A149 () Bool
+    false)
+  (define-fun A167 () Bool
+    true)
+  (define-fun A166 () Bool
+    false)
+  (define-fun A51 () Bool
+    false)
+  (define-fun A72 () Bool
+    false)
+  (define-fun A118 () Bool
+    false)
+  (define-fun A93 () Bool
+    true)
+  (define-fun A165 () Bool
+    false)
+  (define-fun A62 () Bool
+    true)
+  (define-fun A73 () Bool
+    false)
+  (define-fun A65 () Bool
+    true)
+  (define-fun A24 () Bool
+    false)
+  (define-fun A94 () Bool
+    false)
+  (define-fun A26 () Bool
+    false)
+  (define-fun A139 () Bool
+    false)
+  (define-fun A58 () Bool
+    false)
+  (define-fun A148 () Bool
+    false)
+  (define-fun A159 () Bool
+    false)
+  (define-fun A12 () Bool
+    false)
+  (define-fun A96 () Bool
+    false)
+  (define-fun A54 () Bool
+    false)
+  (define-fun A84 () Bool
+    false)
+  (define-fun A185 () Bool
+    false)
+  (define-fun A105 () Bool
+    true)
+  (define-fun A9 () Bool
+    true)
+  (define-fun A101 () Bool
+    false)
+  (define-fun A31 () Bool
+    false)
+  (define-fun A7 () Bool
+    true)
+  (define-fun A81 () Bool
+    false)
+  (define-fun A10 () Bool
+    false)
+  (define-fun A15 () Bool
+    false)
+  (define-fun A140 () Bool
+    false)
+  (define-fun A169 () Bool
+    false)
+  (define-fun A90 () Bool
+    false)
+  (define-fun A112 () Bool
+    false)
+  (define-fun A37 () Bool
+    true)
+  (define-fun A6 () Bool
+    true)
+  (define-fun A66 () Bool
+    false)
+  (define-fun A32 () Bool
+    true)
+  (define-fun A142 () Bool
+    false)
+  (define-fun A60 () Bool
+    false)
+  (define-fun A2 () Bool
+    false)
+  (define-fun A257 () Bool
+    true)
+  (define-fun A27 () Bool
+    false)
+  (define-fun A119 () Bool
+    true)
+  (define-fun A221 () Bool
+    true)
+  (define-fun A5 () Bool
+    true)
+  (define-fun A136 () Bool
+    false)
+  (define-fun A113 () Bool
+    true)
+  (define-fun A52 () Bool
+    false)
+  (define-fun A14 () Bool
+    true)
+  (define-fun A141 () Bool
+    true)
+  (define-fun A250 () Bool
+    false)
+  (define-fun A50 () Bool
+    false)
+  (define-fun A1 () Bool
+    true)
+  (define-fun A168 () Bool
+    false)
+  (define-fun A132 () Bool
+    false)
+  (define-fun A199 () Bool
+    false)
+  (define-fun A4 () Bool
+    true)
+  (define-fun A135 () Bool
+    false)
+  (define-fun A146 () Bool
+    false)
+  (define-fun A30 () Bool
+    false)
+  (define-fun A25 () Bool
+    true)
+  (define-fun A3 () Bool
+    false)
+  (define-fun A237 () Bool
+    true)
+  (define-fun A115 () Bool
+    true)
+  (define-fun A153 () Bool
+    true)
+  (define-fun A156 () Bool
+    true)
+  (define-fun A11 () Bool
+    true)
+  (define-fun A69 () Bool
+    true)
+  (define-fun A8 () Bool
+    false)
+  (define-fun A170 () Bool
+    false)
+  (define-fun A108 () Bool
+    true)
+  (define-fun A97 () Bool
+    false)
+  (define-fun A80 () Bool
+    false)
+  (define-fun A95 () Bool
+    true)
+  (define-fun A129 () Bool
+    true)
+  (define-fun A134 () Bool
+    true)
+  (define-fun A41 () Bool
+    false)
+  (define-fun A120 () Bool
+    false)
+  (define-fun A57 () Bool
+    true)
+  (define-fun A13 () Bool
+    true)
+  (define-fun A294 () Bool
+    true)
+  (define-fun A175 () Bool
+    true)
+  (define-fun A291 () Bool
+    true)
+  (define-fun A288 () Bool
+    true)
+  (define-fun A284 () Bool
+    false)
+  (define-fun A280 () Bool
+    true)
+  (define-fun A276 () Bool
+    false)
+  (define-fun A264 () Bool
+    false)
+  (define-fun A260 () Bool
+    true)
+  (define-fun A254 () Bool
+    false)
+  (define-fun A247 () Bool
+    false)
+  (define-fun A244 () Bool
+    false)
+  (define-fun A241 () Bool
+    false)
+  (define-fun A234 () Bool
+    false)
+  (define-fun A230 () Bool
+    true)
+  (define-fun A227 () Bool
+    false)
+  (define-fun A224 () Bool
+    true)
+  (define-fun A218 () Bool
+    true)
+  (define-fun A215 () Bool
+    true)
+  (define-fun A212 () Bool
+    false)
+  (define-fun A207 () Bool
+    false)
+  (define-fun A204 () Bool
+    true)
+  (define-fun A196 () Bool
+    false)
+  (define-fun A192 () Bool
+    true)
+  (define-fun A189 () Bool
+    false)
+  (define-fun A182 () Bool
+    true)
+  (define-fun A179 () Bool
+    true)
+  (define-fun A123 () Bool
+    true)
+  (define-fun A87 () Bool
+    false)
+  (define-fun A77 () Bool
+    true)
+  (define-fun A47 () Bool
+    true)
+  (define-fun A40 () Bool
+    false)
+  (define-fun A35 () Bool
+    false)
+  (define-fun A19 () Bool
+    false)
+  (define-fun A211 () Bool
+    false)
+  (define-fun A246 () Bool
+    false)
+  (define-fun A191 () Bool
+    false)
+  (define-fun A92 () Bool
+    false)
+  (define-fun A251 () Bool
+    false)
+  (define-fun A107 () Bool
+    false)
+  (define-fun A279 () Bool
+    false)
+  (define-fun A68 () Bool
+    false)
+  (define-fun A187 () Bool
+    false)
+  (define-fun A201 () Bool
+    false)
+  (define-fun A261 () Bool
+    false)
+  (define-fun A64 () Bool
+    false)
+  (define-fun A152 () Bool
+    false)
+  (define-fun A22 () Bool
+    false)
+  (define-fun A145 () Bool
+    false)
+  (define-fun A235 () Bool
+    false)
+  (define-fun A18 () Bool
+    false)
+  (define-fun A46 () Bool
+    false)
+  (define-fun A188 () Bool
+    false)
+  (define-fun A255 () Bool
+    false)
+  (define-fun A130 () Bool
+    false)
+  (define-fun A290 () Bool
+    false)
+  (define-fun A283 () Bool
+    false)
+  (define-fun A197 () Bool
+    false)
+  (define-fun A231 () Bool
+    false)
+  (define-fun A91 () Bool
+    false)
+  (define-fun A56 () Bool
+    false)
+  (define-fun A160 () Bool
+    false)
+  (define-fun A226 () Bool
+    false)
+  (define-fun A155 () Bool
+    false)
+  (define-fun A29 () Bool
+    false)
+  (define-fun A70 () Bool
+    false)
+  (define-fun A116 () Bool
+    false)
+  (define-fun A125 () Bool
+    false)
+  (define-fun A252 () Bool
+    false)
+  (define-fun A210 () Bool
+    false)
+  (define-fun A198 () Bool
+    false)
+  (define-fun A217 () Bool
+    false)
+  (define-fun A228 () Bool
+    false)
+  (define-fun A269 () Bool
+    false)
+  (define-fun A277 () Bool
+    false)
+  (define-fun A34 () Bool
+    false)
+  (define-fun A45 () Bool
+    false)
+  (define-fun A271 () Bool
+    false)
+  (define-fun A178 () Bool
+    false)
+  (define-fun A63 () Bool
+    false)
+  (define-fun A220 () Bool
+    false)
+  (define-fun A181 () Bool
+    false)
+  (define-fun A275 () Bool
+    false)
+  (define-fun A43 () Bool
+    false)
+  (define-fun A86 () Bool
+    false)
+  (define-fun A38 () Bool
+    false)
+  (define-fun A122 () Bool
+    false)
+  (define-fun A202 () Bool
+    false)
+  (define-fun A174 () Bool
+    false)
+  (define-fun A243 () Bool
+    false)
+  (define-fun A176 () Bool
+    false)
+  (define-fun A229 () Bool
+    false)
+  (define-fun A263 () Bool
+    false)
+  (define-fun A273 () Bool
+    false)
+  (define-fun A75 () Bool
+    false)
+  (define-fun A124 () Bool
+    false)
+  (define-fun A151 () Bool
+    false)
+  (define-fun A256 () Bool
+    false)
+  (define-fun A281 () Bool
+    false)
+  (define-fun A183 () Bool
+    false)
+  (define-fun A236 () Bool
+    false)
+  (define-fun A28 () Bool
+    false)
+  (define-fun A144 () Bool
+    false)
+  (define-fun A262 () Bool
+    false)
+  (define-fun A205 () Bool
+    false)
+  (define-fun A274 () Bool
+    false)
+  (define-fun A177 () Bool
+    false)
+  (define-fun A83 () Bool
+    false)
+  (define-fun A253 () Bool
+    false)
+  (define-fun A239 () Bool
+    false)
+  (define-fun A85 () Bool
+    false)
+  (define-fun A223 () Bool
+    false)
+  (define-fun A117 () Bool
+    false)
+  (define-fun A242 () Bool
+    false)
+  (define-fun A158 () Bool
+    false)
+  (define-fun A190 () Bool
+    false)
+  (define-fun A240 () Bool
+    false)
+  (define-fun A286 () Bool
+    false)
+  (define-fun A248 () Bool
+    false)
+  (define-fun A233 () Bool
+    false)
+  (define-fun A292 () Bool
+    false)
+  (define-fun A282 () Bool
+    false)
+  (define-fun A268 () Bool
+    false)
+  (define-fun A33 () Bool
+    false)
+  (define-fun A17 () Bool
+    false)
+  (define-fun A287 () Bool
+    false)
+  (define-fun A106 () Bool
+    false)
+  (define-fun A71 () Bool
+    false)
+  (define-fun A21 () Bool
+    false)
+  (define-fun A209 () Bool
+    false)
+  (define-fun A109 () Bool
+    false)
+  (define-fun A186 () Bool
+    false)
+  (define-fun A213 () Bool
+    false)
+  (define-fun A232 () Bool
+    false)
+  (define-fun A249 () Bool
+    false)
+  (define-fun A285 () Bool
+    false)
+  (define-fun A99 () Bool
+    false)
+  (define-fun A200 () Bool
+    false)
+  (define-fun A222 () Bool
+    false)
+  (define-fun A289 () Bool
+    false)
+  (define-fun A157 () Bool
+    false)
+  (define-fun A219 () Bool
+    false)
+  (define-fun A131 () Bool
+    false)
+  (define-fun A259 () Bool
+    false)
+  (define-fun A293 () Bool
+    false)
+  (define-fun A138 () Bool
+    false)
+  (define-fun A245 () Bool
+    false)
+  (define-fun A266 () Bool
+    false)
+  (define-fun A55 () Bool
+    false)
+  (define-fun A39 () Bool
+    false)
+  (define-fun A193 () Bool
+    false)
+  (define-fun A203 () Bool
+    false)
+  (define-fun A67 () Bool
+    false)
+  (define-fun A238 () Bool
+    false)
+  (define-fun A208 () Bool
+    false)
+  (define-fun A42 () Bool
+    false)
+  (define-fun A173 () Bool
+    false)
+  (define-fun A278 () Bool
+    false)
+  (define-fun A89 () Bool
+    false)
+  (define-fun A184 () Bool
+    false)
+  (define-fun A206 () Bool
+    false)
+  (define-fun A214 () Bool
+    false)
+  (define-fun A49 () Bool
+    false)
+  (define-fun A161 () Bool
+    false)
+  (define-fun A216 () Bool
+    false)
+  (define-fun A225 () Bool
+    false)
+  (define-fun A88 () Bool
+    false)
+  (define-fun A194 () Bool
+    false)
+  (define-fun A195 () Bool
+    false)
+  (define-fun A48 () Bool
+    false)
+  (define-fun A76 () Bool
+    false)
+  (define-fun A154 () Bool
+    false)
+  (define-fun A110 () Bool
+    false)
+  (define-fun A258 () Bool
+    false)
+  (define-fun A121 () Bool
+    false)
+  (define-fun A180 () Bool
+    false)
+  (define-fun A270 () Bool
+    false)
+  (define-fun A163 () Bool
+    false)
+  (define-fun A265 () Bool
+    false)
+  (define-fun A137 () Bool
+    false)
+  (define-fun A128 () Bool
+    false)
+  (define-fun A127 () Bool
+    false)
+  (define-fun A164 () Bool
+    false)
+  (define-fun A98 () Bool
+    false)
+  (define-fun A82 () Bool
+    false)
+)
diff --git a/sweep.cpp b/sweep.cpp
index ed0cc40..12d6482 100644
--- a/sweep.cpp
+++ b/sweep.cpp
@@ -1,4 +1,5 @@
 #include "sweep.hpp"
+#include "src/cadical.hpp"
 #include "circuit.hpp"
   
 extern "C" {
@@ -9,11 +10,106 @@ int Sweep::get_time() {
     return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - clk_st).count();
 }
 
+void Sweep::cal_topo_index() {
+
+    int cnt = 0;
+
+    std::queue<int> q;
+    for(int i=0; i<aig->num_inputs; i++) {
+        int input = aiger_lit2var(aig->inputs[i].lit);
+        topo_index[input] = ++cnt;
+        q.push(input);
+    }
+
+    
+
+    static int* topo_counter = new int[maxvar + 1];
+    memset(topo_counter, 0, (maxvar + 1) * sizeof(int));
+
+    while(!q.empty()) {
+        int cur = q.front();
+        q.pop();
+        for(auto& edge : graph.edge[cur]) {
+            int v = edge.to;
+            topo_counter[v]++;
+            if(topo_counter[v] == 2) {
+                q.push(v);
+                topo_index[v] = ++cnt;
+            }
+        }
+    }
+
+    for(int i=1; i<=maxvar; i++) {
+        rtopo_index[i] = maxvar - topo_index[i] + 1;
+        //printf("topo[%d]=%d\n", i, rtopo_index[i]);
+    }
+}
+
+
+void Sweep::miter() {
+
+    std::queue<int> q;
+    
+    int x = aiger_lit2var(output);
+
+    if (!used[x])
+        q.push(x), used[x] = true;
+
+    while(!q.empty()) {
+        int u = q.front();
+        q.pop();
+
+        if(graph.redge[u].size() == 0) {
+            //cout << "oh FUCK" << endl;
+            continue;
+        }
+
+        int a = graph.redge[u][0].to;
+        int b = graph.redge[u][1].to;
+
+        if(graph.redge[u][0].neg) a = -a;
+        if(graph.redge[u][1].neg) b = -b;
+        
+
+        solver->add(-u); solver->add(a); solver->add(0);
+        solver->add(-u); solver->add(b); solver->add(0);
+        solver->add(-a); solver->add(-b); solver->add(u); solver->add(0);
+
+        a = abs(a);
+        b = abs(b);
+
+        if(!used[a]) {
+            q.push(a);
+            used[a] = true;
+        }
+
+        if(!used[b]) {
+            q.push(b);
+            used[b] = true;
+        }
+
+    }
+
+    if(output & 1) {
+        solver->add(-x); solver->add(0);
+    } else {
+        solver->add(x); solver->add(0);
+    }
+    
+
+    int result = solver->solve ();
+
+    delete solver;
+
+    printf("c final: %d\n", result);
+
+    return;
+}
+
 void Sweep::aiger_preprocess() {
     aiger_read_from_file(aig, file);
     maxvar = aig->maxvar;
     output = aig->outputs[0].lit;
-    num_inputs = aig->num_inputs;
 
     used = new int[maxvar + 1];
     C = new circuit[maxvar + 1];
@@ -45,6 +141,7 @@ void Sweep::aiger_preprocess() {
     //     }
     //     puts(")");
     // }
+    cal_topo_index();
     return;
 
     printf("c inputs: \nc ");
@@ -65,12 +162,106 @@ void Sweep::aiger_preprocess() {
         printf(" %d", det_v[i]);
     }
     puts("");
-    cal_topo_index();
+}
+
+void Sweep::check_with_SAT() {
+    printf("c =================================== check =================================\n");
+
+    for(auto& clas : classes) {
+        //if(clas.size() != 2) continue;
+        int lit = clas[0];
+        if (sum_pos[lit] == 0 || sum_neg[lit] == 0) {
+            // printf("c Find ALWAYS NEG SET\n");
+            for(int i=0; i<clas.size(); i++) {
+                if (clas[i] & 1) continue;
+                int vara =  aiger_lit2var(clas[i]);
+                pairs.push_back(std::make_pair(topo_index[vara], std::make_pair(clas[i], !sum_pos[lit] ? 0 : -1)));      
+            }
+            continue;
+        }
+
+        for(int i=0; i<clas.size(); i++) {
+            for(int j=i+1; j<clas.size(); j++) {
+                if ((clas[i] & 1) & (clas[j] & 1)) continue;    
+                int vara =  aiger_lit2var(clas[i]);
+                int varb =  aiger_lit2var(clas[j]);
+                if (abs(vara - varb) <= 5) {printf("%d %d\n", clas[i], clas[j]); continue;}
+                pairs.push_back(std::make_pair(std::max(topo_index[vara], topo_index[varb]), std::make_pair(clas[i], clas[j])));      
+            }
+        }
+    }
+    sort(pairs.begin(), pairs.end());
+
+    if (det_v_sz) {
+        for (int i = 0; i < det_v_sz; i++) {
+            solver->add(det_v[i]);
+            solver->add(0);
+        }
+    }
+
+    int s = 0, pair_cnt = 0, nv = maxvar;
+    auto clk_ori_st = clk_st;
+    printf("c Number of pairs detected: %d\n", pairs.size());
+    for(auto& pr : pairs) {
+        clk_st = std::chrono::high_resolution_clock::now();
+        int a = pr.second.first;
+        int b = pr.second.second;
+        printf("[%4d/%4d]   check-eq %6d %6d: ", ++pair_cnt, pairs.size(), a, abs(b));
+        ++nv;
+        if (b > 0) { //check a = b
+            if(check_var_equal(a, b, -nv)) {
+                printf("  YES (%7.2lf s)\n", 0.001 * get_time());
+                ++s;
+                
+                int x = a & 1 ? -aiger_lit2var(a) : aiger_lit2var(a);
+                int y = b & 1 ? -aiger_lit2var(b) : aiger_lit2var(b);
+                    
+                solver->add(-x), solver->add( y), solver->add(0);
+                solver->add( x), solver->add(-y), solver->add(0);
+
+            }
+            else printf("  \t\t\t NO (%7.2lf s)\n", 0.001 * get_time());
+        }
+        else { //check a = 1 or a = 0
+            int val = abs(b);
+            if(check_constant(a, val)) {
+                printf("  YES (%7.2lf s)\n", 0.001 * get_time());
+                ++s;
+                
+                int x = a & 1 ? -aiger_lit2var(a) : aiger_lit2var(a);
+                
+                solver->add(x * (val ? 1 : -1));
+                solver->add(0);
+            }
+            else printf("  \t\t\t NO (%7.2lf s)\n", 0.001 * get_time());
+        }
+    }
+    printf("c Number of equivalent pairs: %d\n", s);
+    clk_st = clk_ori_st;
 }
 
 void Sweep::solve() {
     aiger_preprocess();
-    printf("c preprocess finish: %.2lf s\n", 0.001 * get_time());
+    //printf("c preprocess finish: %.2lf s\n", 0.001 * get_time());
     identify();
-    printf("c identify finish: %.2lf s\n", 0.001 * get_time());
+    //simulation();
+    return;
+    printf("c simulation finish: %.2lf s\n", 0.001 * get_time());
+
+    check_with_SAT();
+    printf("c check finish: %.2lf s\n", 0.001 * get_time());
+    
+    miter();
+    printf("c miter finish: %.2lf s\n", 0.001 * get_time());
 }
+
+
+
+// int main(int argv, char* args[]) {
+//     printf("c =================================== input =================================\n");
+//     Sweep *S = sweep_init(argv, args);
+//     S->solve();
+    
+//     return 0;
+// }
+
diff --git a/sweep.hpp b/sweep.hpp
index 5a7cb22..894c28f 100644
--- a/sweep.hpp
+++ b/sweep.hpp
@@ -8,10 +8,10 @@
 namespace CaDiCaL {
     struct Solver;
 }
-
 struct aiger;
 struct circuit;
 
+
 class Graph {
 public:
     struct Edge {
@@ -37,9 +37,9 @@ public:
     FILE* file;
     Graph graph;
 
-    int maxvar, output, num_inputs;
+    int maxvar, output;
 
-    int *used, *det_v, *is_cut, *sum_pos, *sum_neg, *del;
+    int *used, *det_v, *seen, *sum_pos, *sum_neg, *del;
     int det_v_sz = 0;
     int rounds;
 
@@ -47,7 +47,13 @@ public:
 
     circuit *C;
     aiger *aig;
+    CaDiCaL::Solver * solver;
     std::map<int, int> topo_index;
+    std::map<int, int> rtopo_index;
+    std::set<std::pair<int, int>> eqp;
+    std::vector<std::vector<int>> classes;
+    std::vector<std::pair<int, std::pair<int, int>> > pairs;
+    vec<int> *inv_C;
 
     void solve();
 
@@ -56,6 +62,8 @@ public:
     void cal_topo_index();
 
     void propagate(int* input, int* result);
+
+    void circuit_propagate(int* input, int* result);
     
     void random_simulation();
 
diff --git a/term.cpp b/term.cpp
new file mode 100644
index 0000000..d436d62
--- /dev/null
+++ b/term.cpp
@@ -0,0 +1,276 @@
+/*------------------------------------------------------------------------*/
+/*! \file term.cpp
+    \brief contains the class Term and further functions to
+    manipulate terms
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#include "term.h"
+/*------------------------------------------------------------------------*/
+
+Term::Term(const Var * _v,  Term * _r, uint64_t _hash, Term * _n):
+  variable(_v), ref(1), hash(_hash), next(_n) {
+  if (_r) rest = _r->copy();
+  else
+    rest = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+Term * Term::copy() {
+  assert(ref > 0);
+  ++ref;
+  assert(ref);
+  return this;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Term::print(FILE * file) const {
+  const Term * tmp = this;
+  if (!tmp) fputc_unlocked('0', file);
+  while (tmp) {
+    fputs_unlocked(tmp->get_var_name(), file);
+    tmp = tmp->get_rest();
+    if (tmp) fputc_unlocked('*', file);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+unsigned Term::size() const {
+  const Term * tmp = this;
+  if (!tmp) return 0;
+
+  int i = 0;
+  while (tmp) {
+    i++;
+    tmp = tmp->get_rest();
+  }
+  return i;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Term::cmp(const Term *t) const {
+  const Term * tmp1 = this;
+  if (!tmp1) return -1;
+  const Term * tmp2 = t;
+  if (!tmp2) return 1;
+
+  if (tmp1 != tmp2) {
+    while (tmp1 && tmp2) {
+      if (tmp1->get_var_level() > tmp2->get_var_level()) return 1;
+      else if (tmp1->get_var_level() < tmp2->get_var_level()) return -1;
+      tmp1 = tmp1->get_rest();
+      tmp2 = tmp2->get_rest();
+    }
+    if (tmp1) return 1;
+    else if (tmp2) return -1;
+  }
+
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Term::contains(const Var *v) const {
+  assert(v);
+  const Term * t = this;
+  while (t) {
+    if (t->get_var() == v) return 1;
+    else if (t->get_var_level() < v->get_level()) return 0;
+    t = t->get_rest();
+  }
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+uint64_t size_terms;
+uint64_t current_terms;
+Term ** term_table;
+
+/*------------------------------------------------------------------------*/
+
+uint64_t compute_hash_term(const Var * variable, const Term * rest) {
+  assert(variable);
+  uint64_t res = rest ? rest->get_hash() : 0;
+  res *= get_nonces_entry(0);
+  res += variable->get_hash();
+  res *= get_nonces_entry(1);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void enlarge_terms() {
+  uint64_t new_size_terms = size_terms ? 2*size_terms : 1;
+  Term ** new_term_table = new Term*[new_size_terms]();
+  for (uint64_t i = 0; i < size_terms; i++) {
+    for (Term * m = term_table[i], * n; m; m = n) {
+      uint64_t h = m->get_hash() &(new_size_terms - 1);
+      n = m->get_next();
+      m->set_next(new_term_table[h]);
+      new_term_table[h] = m;
+    }
+  }
+  delete[] term_table;
+  term_table = new_term_table;
+  size_terms = new_size_terms;
+}
+
+/*------------------------------------------------------------------------*/
+
+Term * new_term(const Var * variable, Term * rest) {
+  if (current_terms == size_terms) enlarge_terms();
+  const uint64_t hash = compute_hash_term(variable, rest);
+  const uint64_t h = hash &(size_terms - 1);
+
+  Term * res;
+  for (res = term_table[h];
+       res &&(res->get_var() != variable || res->get_rest() != rest);
+       res = res->get_next())
+       {}
+
+  if (res) {
+    res->inc_ref();  // here we extend that we found term once more
+  } else {
+    res = new Term(variable, rest, hash, term_table[h]);
+    term_table[h] = res;
+    current_terms++;
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void deallocate_term(Term * t) {
+  while (t) {
+    assert(t->get_ref() > 0);
+    if (t->dec_ref() > 0) break;  // t is still used
+    Term * rest = t->get_rest();
+    const uint64_t h = t->get_hash() &(size_terms - 1);
+    Term * p = term_table[h];
+    if (p == t) { term_table[h] = t->get_next();
+    } else {
+      Term * p2;
+      while ((p2 = p->get_next()) != t) p = p2;
+      p->set_next(t->get_next());
+    }
+
+    assert(current_terms);
+    current_terms--;
+    delete(t);
+    t = rest;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void deallocate_terms() {
+  for (uint64_t i = 0; i < size_terms; i++) {
+    for (Term * m = term_table[i], *n; m; m = n) {
+      n = m->get_next();
+      assert(current_terms);
+      current_terms--;
+
+      delete(m);
+    }
+  }
+  delete[] term_table;
+}
+
+/*------------------------------------------------------------------------*/
+static std::stack<const Var*> vstack;  // /< used to build a term
+/*------------------------------------------------------------------------*/
+
+void add_to_vstack(const Var* v) {
+  assert(v);
+  vstack.push(v);
+}
+
+bool var_cmp(const Var* a, const Var* b) {
+  return a->get_level() > b->get_level();
+}
+
+/*------------------------------------------------------------------------*/
+
+Term * build_term_from_stack() {
+  std::vector<const Var*> tmp_vec;
+  while(!vstack.empty()) tmp_vec.push_back(vstack.top()), vstack.pop();
+  std::sort(tmp_vec.begin(), tmp_vec.end(), var_cmp);
+  for(auto v : tmp_vec) vstack.push(v);
+
+  Term * res = 0;
+  while (!vstack.empty()) {
+    Term * t = new_term(vstack.top(), res);
+    assert(t);
+
+    vstack.pop();
+    deallocate_term(res);
+    res = t;
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+Term * multiply_term(Term * t1, Term * t2) {
+  if (!t1 || !t2) return 0;
+  if (t1 == t2) return t1->copy();
+
+  const Term * tmp1 = t1;
+  const Term * tmp2 = t2;
+
+
+  while (tmp1 && tmp2) {
+    if (tmp1->get_var_level() > tmp2->get_var_level()) {
+      vstack.push(tmp1->get_var());
+      tmp1 = tmp1->get_rest();
+    } else if (tmp1->get_var_level() < tmp2->get_var_level()) {
+      vstack.push(tmp2->get_var());
+      tmp2 = tmp2->get_rest();
+    } else {
+      vstack.push(tmp1->get_var());
+      tmp1 = tmp1->get_rest();
+      tmp2 = tmp2->get_rest();
+    }
+  }
+
+  while (tmp1) {
+    vstack.push(tmp1->get_var());
+    tmp1 = tmp1->get_rest();
+  }
+
+  while (tmp2) {
+    vstack.push(tmp2->get_var());
+    tmp2 = tmp2->get_rest();
+  }
+  Term * t = build_term_from_stack();
+
+  return t;
+}
+
+/*------------------------------------------------------------------------*/
+
+Term * remainder(const Term * t, const Var * v) {
+  assert(v);
+
+
+  while (t) {
+    const Var * v1 = t->get_var();
+
+    if (v1 == v) {
+      t = t->get_rest();
+    } else {
+      vstack.push(v1);
+      t = t->get_rest();
+    }
+  }
+
+  Term * res = build_term_from_stack();
+  return res;
+}
diff --git a/term.h b/term.h
new file mode 100644
index 0000000..4e85455
--- /dev/null
+++ b/term.h
@@ -0,0 +1,246 @@
+/*------------------------------------------------------------------------*/
+/*! \file term.h
+    \brief contains the class Term and further functions to
+    manipulate terms
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#ifndef AMULET2_SRC_TERM_H_
+#define AMULET2_SRC_TERM_H_
+/*------------------------------------------------------------------------*/
+#include <stack>
+#include <vector>
+#include <algorithm>
+
+#include "variable.h"
+/*------------------------------------------------------------------------*/
+
+/** \class Term
+    This class is used to represent terms in a polynomial.
+    Terms are represented as ordered linked lists of variables.
+*/
+
+class Term {
+  // / head variable
+  const Var * variable;
+
+  // / tail in linked list
+  Term * rest;
+
+  // / reference counter
+  uint64_t ref;
+
+  // / hash value
+  const uint64_t hash;
+
+  // / hash collision chain link
+  Term * next;
+
+ public:
+  /** Constructor
+
+      @param _v Var*
+      @param _r Term*
+      @param _hash uint64_t
+      @param _n Term*
+  */
+  Term(const Var * _v, Term * _r, uint64_t _hash, Term * _n);
+
+  /** Getter for member variable
+
+      @return Var*
+  */
+  const Var * get_var() const {return variable;}
+
+  /** Getter for level of variable
+
+      @return integer
+  */
+  int get_var_level() const {return variable->get_level();}
+
+  /** Getter for num of variable
+
+      @return integer
+  */
+  int get_var_num() const {return variable->get_num();}
+
+  /** Getter for name of variable
+
+      @return char*
+  */
+  const char * get_var_name() const {return variable->get_name();}
+
+  /** Getter for member rest
+
+      @return Term*
+  */
+  Term * get_rest() const {return rest;}
+
+  /** Getter for member hash
+
+      @return uint64_t
+  */
+  uint64_t get_hash() const {return hash;}
+
+  /** Getter for member next
+
+      @return Term*
+  */
+  Term * get_next() const {return next;}
+
+  /** Setter for member term
+
+      @param t Term*
+  */
+  void set_next(Term * t) {next = t;}
+
+  /** Getter for member ref
+
+      @return uint64_t
+  */
+  uint64_t get_ref() const {return ref;}
+
+  /** Increases ref
+
+      @return uint64_t
+  */
+  uint64_t inc_ref() {return ++ref;}
+
+  /** Decreases ref
+
+      @return uint64_t
+  */
+  uint64_t dec_ref() {return --ref;}
+
+  /**
+      Copy routine
+
+      @return A copy of the current term
+  */
+  Term * copy();
+
+  /**
+      Printing routine
+
+      @param file Output file
+  */
+  void print(FILE * file) const;
+
+  /**
+      Returns the number of variables in a term
+
+      @return unsigned integer
+  */
+  unsigned size() const;
+
+  /**
+      Compares this term to term t using the levels of the variables
+
+      @param t Term*
+
+      @return +1 if this > t
+              -1 if this < t
+              0  if this = t
+  */
+  int cmp(const Term *t) const;
+
+  /**
+      Checks whether v is contained in Term
+
+      @param v Var*
+
+      @return true if v is contained in term
+  */
+  bool contains(const Var * v) const;
+};
+
+/*------------------------------------------------------------------------*/
+// We organize terms in a hash table that is dynamically enlarged.
+// Every time a new term is defined, we compute a hash value and insert
+// the term. Terms are counted using a reference counter, which is incremented
+// and decremented depending how often the term occurs in polynomials.
+
+/**
+    Compute hash_values
+
+    @param variable Variable*
+    @param rest Term*
+
+    @return computed hash value for the term(variable, rest)
+*/
+uint64_t compute_hash_term(const Var * variable, const Term * rest);
+
+/**
+    Enlarges the hash table
+*/
+void enlarge_terms();
+
+/**
+    Builds a term, where variable is added at the front of rest
+
+    @param variable Variable*
+    @param rest     Term*
+
+    @return Term*
+*/
+Term * new_term(const Var * variable, Term * rest);
+
+
+
+/**
+    Decrements the reference count of a term, and actually deletes a
+    term if its reference count goes to zero.  In this case it also
+    removes it from the hash table and applies the same procedure to the
+    suffix 'rest'.
+
+    @param t Term*
+*/
+void deallocate_term(Term * t);
+
+
+/**
+    Deallocates the hash table "term_table"
+*/
+void deallocate_terms();
+
+/*------------------------------------------------------------------------*/
+// Terms are generated using a stack "vstack"
+
+/**
+    Pushes a variable to the variable stack, thus variables have to be pushed
+    in order
+
+    @param v Var*
+*/
+void add_to_vstack(const Var* v);
+
+/**
+    Generates a term from the variable stack
+
+    @return Term* generated from the variable stack
+*/
+Term * build_term_from_stack();
+
+/**
+    Multiplies two terms
+
+    @param t1 Term*
+    @param t2 Term*
+
+    @return Term* which is product of t1*t2
+*/
+Term * multiply_term(Term * t1, Term * t2);
+
+/**
+    Remainder of t divided by v
+
+    @param t Term*
+    @param v Var*
+
+    @return Term* where v is removed from t
+*/
+Term * remainder(const Term * t, const Var * v);
+
+#endif  // AMULET2_SRC_TERM_H_
diff --git a/test.smt b/test.smt
new file mode 100644
index 0000000..69a524a
--- /dev/null
+++ b/test.smt
@@ -0,0 +1,5 @@
+(declare-fun a () Bool)
+(declare-fun b () Bool)
+(assert (= 1 (+ a b)))
+(check-sat)
+(get-model)
diff --git a/variable.h b/variable.h
new file mode 100644
index 0000000..be3adf0
--- /dev/null
+++ b/variable.h
@@ -0,0 +1,74 @@
+/*------------------------------------------------------------------------*/
+/*! \file variable.h
+    \brief contains the class Var
+
+  Part of AMulet2.1 : AIG Multiplier Verification Tool.
+  Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
+*/
+/*------------------------------------------------------------------------*/
+#ifndef AMULET2_SRC_VARIABLE_H_
+#define AMULET2_SRC_VARIABLE_H_
+/*------------------------------------------------------------------------*/
+#include <string>
+
+#include "hash_val.h"
+/*------------------------------------------------------------------------*/
+
+/** \class Var
+    represents a variable is assigned to a gate(see <gate.h>) and is
+    used to represent variables in terms, see <term.h>
+*/
+
+class Var {
+    // / name of variable
+    const std::string name;
+
+    // / Hash value of variables, used for storing terms
+    int hash;
+
+    // / Increasing value that indicates the order of the variable
+    const int level;
+
+    // / corresponding value used to relate AIG gates to Gate class
+    const int num;
+
+ public:
+  /** Constructor
+
+     @param name_ name
+     @param level_ level
+     @param num_ num, default is 0
+
+  */
+  Var(std::string name_, int level_, int num_ = 0):
+     name(name_),  level(level_), num(num_) {
+       hash = hash_string(name_);
+     }
+
+   /** Getter for member name, and converts string to char*
+
+       @return const char *
+   */
+  const char * get_name() const {return name.c_str();}
+
+  /** Getter for member hash
+
+      @return integer
+  */
+  int get_hash() const {return hash;}
+
+  /** Getter for member level
+
+      @return integer
+  */
+  int get_level() const {return level;}
+
+  /** Getter for member num
+
+      @return integer
+  */
+  int get_num() const {return num;}
+};
+
+
+#endif  // AMULET2_SRC_VARIABLE_H_
diff --git a/z3 b/z3
deleted file mode 160000
index e2cfc53..0000000
--- a/z3
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e2cfc53c9fe44690bf4310ad0ce8d0b6deea91f5