diff --git a/.gitignore b/.gitignore
index b9ee5dc..a8b4dfc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,4 +33,5 @@
 
 acec
 amulet2
-build
\ No newline at end of file
+build
+.vscode
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
deleted file mode 100644
index 48cb31a..0000000
--- a/.vscode/settings.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "files.associations": {
-        "*.ejs": "html",
-        "iostream": "cpp",
-        "*.tcc": "cpp",
-        "new": "cpp"
-    }
-}
\ No newline at end of file
diff --git a/acec.cpp b/acec.cpp
index f1248a8..6753172 100644
--- a/acec.cpp
+++ b/acec.cpp
@@ -1,46 +1,8 @@
 #include <bits/stdc++.h>
 
-#include "vec.hpp"
-#include "circuit.hpp"
-#include "sweep.hpp"
-
-//#include "libopenf4.h"
-#include "src/cadical.hpp"
 
 #include "polynomial.h"
 
-extern "C" {
-    #include "aiger.h"
-}
-
-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) {
     
@@ -87,112 +49,112 @@ bool subsitute(Polynomial* &a, Polynomial* b) {
     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();
+// 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->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[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[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[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()));
+//         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();
+//         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()));
+//         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();
-    }
-}
+//         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();
@@ -203,112 +165,109 @@ int main(int argv, char* args[]) {
 
     init_mpz(19260817);
 
-    S = sweep_init(argv, args);
 
-    S->solve();
+    // 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;
+    // }
 
-    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;
-    }
+    // std::vector<Polynomial*> polys;
 
-    std::vector<Polynomial*> polys;
+    // 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);
+    //     }
+    // }
 
-    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());
 
-    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;
-    }
+    // 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(!reserved_vars.count(i)) continue;
 
-        if(!reserved_vars.count(i)) continue;
+    //     //if(c->sz == 2 && abs(c->to[0]) <= 14 && abs(c->to[1]) <= 14) 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);
 
-        Polynomial *resultA, *resultB = nullptr;
-        getPolyOfGate(S, i, resultA, resultB);
+    //     printf("  original:\t"); resultA->print(stdout);
 
-        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);
+    //     }
 
-        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);
 
-        printf("  pos-var:\t"); resultA->print(stdout);
+    //     for(auto subs : subsitute_vars) {
+    //         //printf("delete: "); subs->print(stdout);
+    //         subsitute(resultA, subs);
+    //     }
 
-        for(auto subs : subsitute_vars) {
-            //printf("delete: "); subs->print(stdout);
-            subsitute(resultA, subs);
-        }
+    //     printf("  xor-relative:\t"); resultA->print(stdout);
 
-        printf("  xor-relative:\t"); resultA->print(stdout);
-
-        polys.push_back(resultA);
+    //     polys.push_back(resultA);
         
-        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));
-        }
+    //     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());
+    //     printf(" = %s ( ", gate_type[c->type].c_str());
 
-        for (int j = 0; j < c->sz; j++) {
-            printf("%d ", c->to[j]);
-        }
-        puts(")");
-    }
+    //     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()));
+    // add_to_vstack(pvar(32));
+    // push_mstack(new Monomial(one, build_term_from_stack()));
 
-    Polynomial *result = build_poly();
+    // Polynomial *result = build_poly();
 
-    std::sort(polys.begin(), polys.end(), poly_cmp);
+    // 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);
-    }
+    // for(auto p : polys) {
+    //     printf("now: "); result->print(stdout);
+    //     printf("div: "); p->print(stdout);
+    //     subsitute(result, p);
+    // }
     
     return 0;
 }
diff --git a/acec.log b/acec.log
deleted file mode 100644
index e69de29..0000000
diff --git a/aiger.c b/aiger.c
deleted file mode 100644
index e6e5bb6..0000000
--- a/aiger.c
+++ /dev/null
@@ -1,2775 +0,0 @@
-/***************************************************************************
-Copyright (c) 2011, Siert Wieringa, Aalto University, Finland.
-Copyright (c) 2006-2019, Armin Biere, Johannes Kepler University.
-
-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 "aiger.h"
-
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <ctype.h>
-#include <unistd.h>
-
-
-
-/*------------------------------------------------------------------------*/
-
-// TODO move this to seperate file and sync it with git hash
-
-const char *
-aiger_id (void)
-{
-  return "invalid id";
-}
-
-/*------------------------------------------------------------------------*/
-
-const char *
-aiger_version (void)
-{
-  return AIGER_VERSION;
-}
-
-/*------------------------------------------------------------------------*/
-
-#define GZIP "gzip -c > %s 2>/dev/null"
-#define GUNZIP "gunzip -c %s 2>/dev/null"
-
-#define NEWN(p,n) \
-  do { \
-    size_t bytes = (n) * sizeof (*(p)); \
-    (p) = private->malloc_callback (private->memory_mgr, bytes); \
-    memset ((p), 0, bytes); \
-  } while (0)
-
-#define REALLOCN(p,m,n) \
-  do { \
-    size_t mbytes = (m) * sizeof (*(p)); \
-    size_t nbytes = (n) * sizeof (*(p)); \
-    size_t minbytes = (mbytes < nbytes) ? mbytes : nbytes; \
-    void * res = private->malloc_callback (private->memory_mgr, nbytes); \
-    memcpy (res, (p), minbytes); \
-    if (nbytes > mbytes) \
-      memset (((char*)res) + mbytes, 0, nbytes - mbytes); \
-    private->free_callback (private->memory_mgr, (p), mbytes); \
-    (p) = res; \
-  } while (0)
-
-#define FIT(p,m,n) \
-  do { \
-    size_t old_size = (m); \
-    size_t new_size = (n); \
-    if (old_size < new_size) \
-      { \
-	REALLOCN (p,old_size,new_size); \
-	(m) = new_size; \
-      } \
-  } while (0)
-
-#define ENLARGE(p,s) \
-  do { \
-    size_t old_size = (s); \
-    size_t new_size = old_size ? 2 * old_size : 1; \
-    REALLOCN (p,old_size,new_size); \
-    (s) = new_size; \
-  } while (0)
-
-#define PUSH(p,t,s,l) \
-  do { \
-    if ((t) == (s)) \
-      ENLARGE (p, s); \
-    (p)[(t)++] = (l); \
-  } while (0)
-
-#define DELETEN(p,n) \
-  do { \
-    size_t bytes = (n) * sizeof (*(p)); \
-    private->free_callback (private->memory_mgr, (p), bytes); \
-    (p) = 0; \
-  } while (0)
-
-#define CLR(p) do { memset (&(p), 0, sizeof (p)); } while (0)
-
-#define NEW(p) NEWN (p,1)
-#define DELETE(p) DELETEN (p,1)
-
-#define IMPORT_private_FROM(p) \
-  aiger_private * private = (aiger_private*) (p)
-
-#define EXPORT_public_FROM(p) \
-  aiger * public = &(p)->public
-
-typedef struct aiger_private aiger_private;
-typedef struct aiger_buffer aiger_buffer;
-typedef struct aiger_reader aiger_reader;
-typedef struct aiger_type aiger_type;
-
-struct aiger_type
-{
-  unsigned input:1;
-  unsigned latch:1;
-  unsigned and:1;
-
-  unsigned mark:1;
-  unsigned onstack:1;
-
-  /* Index int to 'public->{inputs,latches,ands}'.
-   */
-  unsigned idx;
-};
-
-struct aiger_private
-{
-  aiger public;
-
-  aiger_type *types;		/* [0..maxvar] */
-  unsigned size_types;
-
-  unsigned char * coi;
-  unsigned size_coi;
-
-  unsigned size_inputs;
-  unsigned size_latches;
-  unsigned size_outputs;
-  unsigned size_ands;
-  unsigned size_bad;
-  unsigned size_constraints;
-  unsigned size_justice;
-  unsigned size_fairness;
-
-  unsigned num_comments;
-  unsigned size_comments;
-
-  void *memory_mgr;
-  aiger_malloc malloc_callback;
-  aiger_free free_callback;
-
-  char *error;
-};
-
-struct aiger_buffer
-{
-  char *start;
-  char *cursor;
-  char *end;
-};
-
-struct aiger_reader
-{
-  void *state;
-  aiger_get get;
-
-  int ch;
-
-  unsigned lineno;
-  unsigned charno;
-
-  unsigned lineno_at_last_token_start;
-
-  int done_with_reading_header;
-  int looks_like_aag;
-
-  aiger_mode mode;
-  unsigned maxvar;
-  unsigned inputs;
-  unsigned latches;
-  unsigned outputs;
-  unsigned ands;
-  unsigned bad;
-  unsigned constraints;
-  unsigned justice;
-  unsigned fairness;
-
-  char *buffer;
-  unsigned top_buffer;
-  unsigned size_buffer;
-};
-
-aiger *
-aiger_init_mem (void *memory_mgr,
-		aiger_malloc external_malloc, aiger_free external_free)
-{
-  aiger_private *private;
-  aiger *public;
-
-  assert (external_malloc);
-  assert (external_free);
-  private = external_malloc (memory_mgr, sizeof (*private));
-  CLR (*private);
-  private->memory_mgr = memory_mgr;
-  private->malloc_callback = external_malloc;
-  private->free_callback = external_free;
-  public = &private->public;
-  PUSH (public->comments, private->num_comments, private->size_comments, 0);
-
-  return public;
-}
-
-static void *
-aiger_default_malloc (void *state, size_t bytes)
-{
-  return malloc (bytes);
-}
-
-static void
-aiger_default_free (void *state, void *ptr, size_t bytes)
-{
-  free (ptr);
-}
-
-aiger *
-aiger_init (void)
-{
-  return aiger_init_mem (0, aiger_default_malloc, aiger_default_free);
-}
-
-static void
-aiger_delete_str (aiger_private * private, char *str)
-{
-  if (str)
-    DELETEN (str, strlen (str) + 1);
-}
-
-static char *
-aiger_copy_str (aiger_private * private, const char *str)
-{
-  char *res;
-
-  if (!str || !str[0])
-    return 0;
-
-  NEWN (res, strlen (str) + 1);
-  strcpy (res, str);
-
-  return res;
-}
-
-static unsigned
-aiger_delete_symbols_aux (aiger_private * private,
-			  aiger_symbol * symbols, unsigned size)
-{
-  unsigned i, res;
-
-  res = 0;
-  for (i = 0; i < size; i++)
-    {
-      aiger_symbol *s = symbols + i;
-      if (!s->name)
-	continue;
-
-      aiger_delete_str (private, s->name);
-      s->name = 0;
-      res++;
-    }
-
-  return res;
-}
-
-static void
-aiger_delete_symbols (aiger_private * private,
-		      aiger_symbol * symbols, unsigned size)
-{
-  aiger_delete_symbols_aux (private, symbols, size);
-  DELETEN (symbols, size);
-}
-
-static unsigned
-aiger_delete_comments (aiger * public)
-{
-  char **start = (char **) public->comments, ** end, ** p;
-  IMPORT_private_FROM (public);
-
-  end = start + private->num_comments;
-  for (p = start; p < end; p++)
-    aiger_delete_str (private, *p);
-
-  private->num_comments = 0;
-  public->comments[0] = 0;
-
-  return private->num_comments;
-}
-
-void
-aiger_reset (aiger * public)
-{
-  unsigned i;
-
-  IMPORT_private_FROM (public);
-
-  aiger_delete_symbols (private, public->inputs, private->size_inputs);
-  aiger_delete_symbols (private, public->latches, private->size_latches);
-  aiger_delete_symbols (private, public->outputs, private->size_outputs);
-  aiger_delete_symbols (private, public->bad, private->size_bad);
-  aiger_delete_symbols (private, public->constraints,
-                        private->size_constraints);
-  for (i = 0; i < public->num_justice; i++)
-    DELETEN (public->justice[i].lits, public->justice[i].size);
-  aiger_delete_symbols (private, public->justice, private->size_justice);
-  aiger_delete_symbols (private, public->fairness, private->size_fairness);
-  DELETEN (public->ands, private->size_ands);
-
-  aiger_delete_comments (public);
-  DELETEN (public->comments, private->size_comments);
-
-  DELETEN (private->coi, private->size_coi);
-
-  DELETEN (private->types, private->size_types);
-  aiger_delete_str (private, private->error);
-  DELETE (private);
-}
-
-static aiger_type *
-aiger_import_literal (aiger_private * private, unsigned lit)
-{
-  unsigned var = aiger_lit2var (lit);
-  EXPORT_public_FROM (private);
-
-  if (var > public->maxvar)
-    public->maxvar = var;
-
-  while (var >= private->size_types)
-    ENLARGE (private->types, private->size_types);
-
-  return private->types + var;
-}
-
-void
-aiger_add_input (aiger * public, unsigned lit, const char *name)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol symbol;
-  aiger_type *type;
-
-  assert (!aiger_error (public));
-
-  assert (lit);
-  assert (!aiger_sign (lit));
-
-  type = aiger_import_literal (private, lit);
-
-  assert (!type->input);
-  assert (!type->latch);
-  assert (!type->and);
-
-  type->input = 1;
-  type->idx = public->num_inputs;
-
-  CLR (symbol);
-  symbol.lit = lit;
-  symbol.name = aiger_copy_str (private, name);
-
-  PUSH (public->inputs, public->num_inputs, private->size_inputs, symbol);
-}
-
-void
-aiger_add_latch (aiger * public,
-		 unsigned lit, unsigned next, const char *name)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol symbol;
-  aiger_type *type;
-
-  assert (!aiger_error (public));
-
-  assert (lit);
-  assert (!aiger_sign (lit));
-
-  type = aiger_import_literal (private, lit);
-
-  assert (!type->input);
-  assert (!type->latch);
-  assert (!type->and);
-
-  /* Warning: importing 'next' makes 'type' invalid.
-   */
-  type->latch = 1;
-  type->idx = public->num_latches;
-
-  aiger_import_literal (private, next);
-
-  CLR (symbol);
-  symbol.lit = lit;
-  symbol.next = next;
-  symbol.name = aiger_copy_str (private, name);
-
-  PUSH (public->latches, public->num_latches, private->size_latches, symbol);
-}
-
-void
-aiger_add_reset (aiger * public, unsigned lit, unsigned reset) 
-{
-  IMPORT_private_FROM (public);
-  aiger_type * type;
-  assert (reset <= 1 || reset == lit);
-  assert (!aiger_error (public));
-  assert (lit);
-  assert (!aiger_sign (lit));
-  type = aiger_import_literal (private, lit);
-  assert (type->latch);
-  assert (type->idx < public->num_latches);
-  public->latches[type->idx].reset = reset;
-}
-
-void
-aiger_add_output (aiger * public, unsigned lit, const char *name)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol symbol;
-  aiger_import_literal (private, lit);
-  CLR (symbol);
-  symbol.lit = lit;
-  symbol.name = aiger_copy_str (private, name);
-  PUSH (public->outputs, public->num_outputs, private->size_outputs, symbol);
-}
-
-void
-aiger_add_bad (aiger * public, unsigned lit, const char *name)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol symbol;
-  aiger_import_literal (private, lit);
-  CLR (symbol);
-  symbol.lit = lit;
-  symbol.name = aiger_copy_str (private, name);
-  PUSH (public->bad, public->num_bad, private->size_bad, symbol);
-}
-
-void
-aiger_add_constraint (aiger * public, unsigned lit, const char *name)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol symbol;
-  aiger_import_literal (private, lit);
-  CLR (symbol);
-  symbol.lit = lit;
-  symbol.name = aiger_copy_str (private, name);
-  PUSH (public->constraints, 
-        public->num_constraints, private->size_constraints, symbol);
-}
-
-void
-aiger_add_justice (aiger * public, 
-                   unsigned size, unsigned * lits,
-		   const char * name)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol symbol;
-  unsigned i, lit;
-  CLR (symbol);
-  symbol.size = size;
-  NEWN (symbol.lits, size);
-  for (i = 0; i < size; i++)
-    {
-      lit = lits[i];
-      aiger_import_literal (private, lit);
-      symbol.lits[i] = lit;
-    }
-  symbol.name = aiger_copy_str (private, name);
-  PUSH (public->justice, 
-        public->num_justice, private->size_justice, symbol);
-}
-
-void
-aiger_add_fairness (aiger * public, unsigned lit, const char *name)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol symbol;
-  aiger_import_literal (private, lit);
-  CLR (symbol);
-  symbol.lit = lit;
-  symbol.name = aiger_copy_str (private, name);
-  PUSH (public->fairness, 
-        public->num_fairness, private->size_fairness, symbol);
-}
-
-void
-aiger_add_and (aiger * public, unsigned lhs, unsigned rhs0, unsigned rhs1)
-{
-  IMPORT_private_FROM (public);
-  aiger_type *type;
-  aiger_and *and;
-
-  assert (!aiger_error (public));
-
-  assert (lhs > 1);
-  assert (!aiger_sign (lhs));
-
-  type = aiger_import_literal (private, lhs);
-
-  assert (!type->input);
-  assert (!type->latch);
-  assert (!type->and);
-
-  type->and = 1;
-  type->idx = public->num_ands;
-
-  aiger_import_literal (private, rhs0);
-  aiger_import_literal (private, rhs1);
-
-  if (public->num_ands == private->size_ands)
-    ENLARGE (public->ands, private->size_ands);
-
-  and = public->ands + public->num_ands;
-
-  and->lhs = lhs;
-  and->rhs0 = rhs0;
-  and->rhs1 = rhs1;
-
-  public->num_ands++;
-}
-
-void
-aiger_add_comment (aiger * public, const char *comment)
-{
-  IMPORT_private_FROM (public);
-  char **p;
-
-  assert (!aiger_error (public));
-
-  assert (!strchr (comment, '\n'));
-  assert (private->num_comments);
-  p = public->comments + private->num_comments - 1;
-  assert (!*p);
-  *p = aiger_copy_str (private, comment);
-  PUSH (public->comments, private->num_comments, private->size_comments, 0);
-}
-
-static const char *
-aiger_error_s (aiger_private * private, const char *s, const char *a)
-{
-  unsigned tmp_len, error_len;
-  char *tmp;
-  assert (!private->error);
-  tmp_len = strlen (s) + strlen (a) + 1;
-  NEWN (tmp, tmp_len);
-  sprintf (tmp, s, a);
-  error_len = strlen (tmp) + 1;
-  NEWN (private->error, error_len);
-  memcpy (private->error, tmp, error_len);
-  DELETEN (tmp, tmp_len);
-  return private->error;
-}
-
-static const char *
-aiger_error_u (aiger_private * private, const char *s, unsigned u)
-{
-  unsigned tmp_len, error_len;
-  char *tmp;
-  assert (!private->error);
-  tmp_len = strlen (s) + sizeof (u) * 4 + 1;
-  NEWN (tmp, tmp_len);
-  sprintf (tmp, s, u);
-  error_len = strlen (tmp) + 1;
-  NEWN (private->error, error_len);
-  memcpy (private->error, tmp, error_len);
-  DELETEN (tmp, tmp_len);
-  return private->error;
-}
-
-static const char *
-aiger_error_uu (aiger_private * private, const char *s, unsigned a,
-		unsigned b)
-{
-  unsigned tmp_len, error_len;
-  char *tmp;
-  assert (!private->error);
-  tmp_len = strlen (s) + sizeof (a) * 4 + sizeof (b) * 4 + 1;
-  NEWN (tmp, tmp_len);
-  sprintf (tmp, s, a, b);
-  error_len = strlen (tmp) + 1;
-  NEWN (private->error, error_len);
-  memcpy (private->error, tmp, error_len);
-  DELETEN (tmp, tmp_len);
-  return private->error;
-}
-
-static const char *
-aiger_error_us (aiger_private * private, const char *s, unsigned a,
-		const char * b)
-{
-  unsigned tmp_len, error_len;
-  char *tmp;
-  assert (!private->error);
-  tmp_len = strlen (s) + sizeof (a) * 4 + strlen (b) + 1;
-  NEWN (tmp, tmp_len);
-  sprintf (tmp, s, a, b);
-  error_len = strlen (tmp) + 1;
-  NEWN (private->error, error_len);
-  memcpy (private->error, tmp, error_len);
-  DELETEN (tmp, tmp_len);
-  return private->error;
-}
-
-static const char *
-aiger_error_usu (aiger_private * private,
-		 const char *s, unsigned a, const char *t, unsigned b)
-{
-  unsigned tmp_len, error_len;
-  char *tmp;
-  assert (!private->error);
-  tmp_len = strlen (s) + strlen (t) + sizeof (a) * 4 + sizeof (b) * 4 + 1;
-  NEWN (tmp, tmp_len);
-  sprintf (tmp, s, a, t, b);
-  error_len = strlen (tmp) + 1;
-  NEWN (private->error, error_len);
-  memcpy (private->error, tmp, error_len);
-  DELETEN (tmp, tmp_len);
-  return private->error;
-}
-
-const char *
-aiger_error (aiger * public)
-{
-  IMPORT_private_FROM (public);
-  return private->error;
-}
-
-static int
-aiger_literal_defined (aiger_private * private, unsigned lit)
-{
-  unsigned var = aiger_lit2var (lit);
-#ifndef NDEBUG
-  EXPORT_public_FROM (private);
-#endif
-  aiger_type *type;
-
-  assert (var <= public->maxvar);
-  if (!var)
-    return 1;
-
-  type = private->types + var;
-
-  return type->and || type->input || type->latch;
-}
-
-static void
-aiger_check_next_defined (aiger_private * private)
-{
-  EXPORT_public_FROM (private);
-  unsigned i, next, latch;
-  aiger_symbol *symbol;
-
-  if (private->error)
-    return;
-
-  for (i = 0; !private->error && i < public->num_latches; i++)
-    {
-      symbol = public->latches + i;
-      latch = symbol->lit;
-      next = symbol->next;
-
-      assert (!aiger_sign (latch));
-      assert (private->types[aiger_lit2var (latch)].latch);
-
-      if (!aiger_literal_defined (private, next))
-	aiger_error_uu (private,
-			"next state function %u of latch %u undefined",
-			next, latch);
-    }
-}
-
-static void
-aiger_check_right_hand_side_defined (aiger_private * private, aiger_and * and,
-				     unsigned rhs)
-{
-  if (private->error)
-    return;
-
-  assert (and);
-  if (!aiger_literal_defined (private, rhs))
-    aiger_error_uu (private, "literal %u in AND %u undefined", rhs, and->lhs);
-}
-
-static void
-aiger_check_right_hand_sides_defined (aiger_private * private)
-{
-  EXPORT_public_FROM (private);
-  aiger_and *and;
-  unsigned i;
-
-  if (private->error)
-    return;
-
-  for (i = 0; !private->error && i < public->num_ands; i++)
-    {
-      and = public->ands + i;
-      aiger_check_right_hand_side_defined (private, and, and->rhs0);
-      aiger_check_right_hand_side_defined (private, and, and->rhs1);
-    }
-}
-
-static void
-aiger_check_outputs_defined (aiger_private * private)
-{
-  EXPORT_public_FROM (private);
-  unsigned i, output;
-
-  if (private->error)
-    return;
-
-  for (i = 0; !private->error && i < public->num_outputs; i++)
-    {
-      output = public->outputs[i].lit;
-      output = aiger_strip (output);
-      if (output <= 1)
-	continue;
-
-      if (!aiger_literal_defined (private, output))
-	aiger_error_u (private, "output %u undefined", output);
-    }
-}
-
-static void
-aiger_check_bad_defined (aiger_private * private)
-{
-  EXPORT_public_FROM (private);
-  unsigned i, bad;
-
-  if (private->error)
-    return;
-
-  for (i = 0; !private->error && i < public->num_bad; i++)
-    {
-      bad = public->bad[i].lit;
-      bad = aiger_strip (bad);
-      if (bad <= 1)
-	continue;
-
-      if (!aiger_literal_defined (private, bad))
-	aiger_error_u (private, "bad %u undefined", bad);
-    }
-}
-
-static void
-aiger_check_constraints_defined (aiger_private * private)
-{
-  EXPORT_public_FROM (private);
-  unsigned i, constraint;
-
-  if (private->error)
-    return;
-
-  for (i = 0; !private->error && i < public->num_constraints; i++)
-    {
-      constraint = public->constraints[i].lit;
-      constraint = aiger_strip (constraint);
-      if (constraint <= 1)
-	continue;
-
-      if (!aiger_literal_defined (private, constraint))
-	aiger_error_u (private, "constraint %u undefined", constraint);
-    }
-}
-
-static void
-aiger_check_fairness_defined (aiger_private * private)
-{
-  EXPORT_public_FROM (private);
-  unsigned i, fairness;
-
-  if (private->error)
-    return;
-
-  for (i = 0; !private->error && i < public->num_fairness; i++)
-    {
-      fairness = public->fairness[i].lit;
-      fairness = aiger_strip (fairness);
-      if (fairness <= 1)
-	continue;
-
-      if (!aiger_literal_defined (private, fairness))
-	aiger_error_u (private, "fairness %u undefined", fairness);
-    }
-}
-
-static void
-aiger_check_justice_defined (aiger_private * private) 
-{
-  EXPORT_public_FROM (private);
-  unsigned i, j, justice;
-
-  if (private->error)
-    return;
-
-  for (i = 0; !private->error && i < public->num_justice; i++)
-    {
-      for (j = 0; !private->error && j < public->justice[i].size; j++)
-	{
-	  justice = public->justice[i].lits[j];
-	  justice = aiger_strip (justice);
-	  if (justice <= 1)
-	    continue;
-
-	  if (!aiger_literal_defined (private, justice))
-	    aiger_error_u (private, "justice %u undefined", justice);
-	}
-    }
-}
-
-static void
-aiger_check_for_cycles (aiger_private * private)
-{
-  unsigned i, j, *stack, size_stack, top_stack, tmp;
-  EXPORT_public_FROM (private);
-  aiger_type *type;
-  aiger_and *and;
-
-  if (private->error)
-    return;
-
-  stack = 0;
-  size_stack = top_stack = 0;
-
-  for (i = 1; !private->error && i <= public->maxvar; i++)
-    {
-      type = private->types + i;
-
-      if (!type->and || type->mark)
-	continue;
-
-      PUSH (stack, top_stack, size_stack, i);
-      while (top_stack)
-	{
-	  j = stack[top_stack - 1];
-
-	  if (j)
-	    {
-	      type = private->types + j;
-	      if (type->mark && type->onstack)
-		{
-		  aiger_error_u (private,
-				 "cyclic definition for and gate %u", j);
-		  break;
-		}
-
-	      if (!type->and || type->mark)
-		{
-		  top_stack--;
-		  continue;
-		}
-
-	      /* Prefix code.
-	       */
-	      type->mark = 1;
-	      type->onstack = 1;
-	      PUSH (stack, top_stack, size_stack, 0);
-
-	      assert (type->idx < public->num_ands);
-	      and = public->ands + type->idx;
-
-	      tmp = aiger_lit2var (and->rhs0);
-	      if (tmp)
-		PUSH (stack, top_stack, size_stack, tmp);
-
-	      tmp = aiger_lit2var (and->rhs1);
-	      if (tmp)
-		PUSH (stack, top_stack, size_stack, tmp);
-	    }
-	  else
-	    {
-	      /* All descendends traversed.  This is the postfix code.
-	       */
-	      assert (top_stack >= 2);
-	      top_stack -= 2;
-	      j = stack[top_stack];
-	      assert (j);
-	      type = private->types + j;
-	      assert (type->mark);
-	      assert (type->onstack);
-	      type->onstack = 0;
-	    }
-	}
-    }
-
-  DELETEN (stack, size_stack);
-}
-
-const char *
-aiger_check (aiger * public)
-{
-  IMPORT_private_FROM (public);
-
-  assert (!aiger_error (public));
-
-  aiger_check_next_defined (private);
-  aiger_check_outputs_defined (private);
-  aiger_check_bad_defined (private);
-  aiger_check_constraints_defined (private);
-  aiger_check_justice_defined (private);
-  aiger_check_fairness_defined (private);
-  aiger_check_right_hand_sides_defined (private);
-  aiger_check_for_cycles (private);
-
-  return private->error;
-}
-
-static int
-aiger_default_get (FILE * file)
-{
-  return getc (file);
-}
-
-static int
-aiger_default_put (char ch, FILE * file)
-{
-  return putc ((unsigned char) ch, file);
-}
-
-static int
-aiger_string_put (char ch, aiger_buffer * buffer)
-{
-  if (buffer->cursor == buffer->end)
-    return EOF;
-  *buffer->cursor++ = ch;
-  return ch;
-}
-
-static int
-aiger_put_s (void *state, aiger_put put, const char *str)
-{
-  const char *p;
-  char ch;
-
-  for (p = str; (ch = *p); p++)
-    if (put (ch, state) == EOF)
-      return EOF;
-
-  return p - str;		/* 'fputs' semantics, >= 0 is OK */
-}
-
-static int
-aiger_put_u (void *state, aiger_put put, unsigned u)
-{
-  char buffer[sizeof (u) * 4];
-  sprintf (buffer, "%u", u);
-  return aiger_put_s (state, put, buffer);
-}
-
-static int
-aiger_write_delta (void *state, aiger_put put, unsigned delta)
-{
-  unsigned char ch;
-  unsigned tmp = delta;
-
-  while (tmp & ~0x7f)
-    {
-      ch = tmp & 0x7f;
-      ch |= 0x80;
-
-      if (put (ch, state) == EOF)
-	return 0;
-
-      tmp >>= 7;
-    }
-
-  ch = tmp;
-  return put (ch, state) != EOF;
-}
-
-static int
-aiger_write_header (aiger * public,
-		    const char *format_string,
-		    int compact_inputs_and_latches,
-		    void *state, aiger_put put)
-{
-  unsigned i, j;
-
-  if (aiger_put_s (state, put, format_string) == EOF) return 0;
-  if (put (' ', state) == EOF) return 0;
-  if (aiger_put_u (state, put, public->maxvar) == EOF) return 0;
-  if (put (' ', state) == EOF) return 0;
-  if (aiger_put_u (state, put, public->num_inputs) == EOF) return 0;
-  if (put (' ', state) == EOF) return 0;
-  if (aiger_put_u (state, put, public->num_latches) == EOF) return 0;
-  if (put (' ', state) == EOF) return 0;
-  if (aiger_put_u (state, put, public->num_outputs) == EOF) return 0;
-  if (put (' ', state) == EOF) return 0;
-  if (aiger_put_u (state, put, public->num_ands) == EOF) return 0;
-
-  if (public->num_bad ||
-      public->num_constraints ||
-      public->num_justice ||
-      public->num_fairness)
-    {
-      if (put (' ', state) == EOF) return 0;
-      if (aiger_put_u (state, put, public->num_bad) == EOF) return 0;
-    }
-
-  if (public->num_constraints ||
-      public->num_justice ||
-      public->num_fairness)
-    {
-      if (put (' ', state) == EOF) return 0;
-      if (aiger_put_u (state, put, public->num_constraints) == EOF) return 0;
-    }
-
-  if (public->num_justice ||
-      public->num_fairness)
-    {
-      if (put (' ', state) == EOF) return 0;
-      if (aiger_put_u (state, put, public->num_justice) == EOF) return 0;
-    }
-
-  if (public->num_fairness)
-    {
-      if (put (' ', state) == EOF) return 0;
-      if (aiger_put_u (state, put, public->num_fairness) == EOF) return 0;
-    }
-
-  if (put ('\n', state) == EOF) return 0;
-
-  if (!compact_inputs_and_latches && public->num_inputs)
-    {
-      for (i = 0; i < public->num_inputs; i++)
-	if (aiger_put_u (state, put, public->inputs[i].lit) == EOF ||
-	    put ('\n', state) == EOF)
-	  return 0;
-    }
-
-  if (public->num_latches)
-    {
-      for (i = 0; i < public->num_latches; i++)
-	{
-	  if (!compact_inputs_and_latches)
-	    {
-	      if (aiger_put_u (state, put, public->latches[i].lit) == EOF)
-	        return 0;
-	      if (put (' ', state) == EOF) return 0;
-	    }
-
-	  if (aiger_put_u (state, put, public->latches[i].next) == EOF)
-	     return 0;
-
-	  if (public->latches[i].reset) 
-	    {
-	      if (put (' ', state) == EOF) return 0;
-	      if (aiger_put_u (state, put, public->latches[i].reset) == EOF)
-		return 0;
-	    }
-	  if (put ('\n', state) == EOF) return 0;
-	}
-    }
-
-  if (public->num_outputs)
-    {
-      for (i = 0; i < public->num_outputs; i++)
-	if (aiger_put_u (state, put, public->outputs[i].lit) == EOF ||
-	    put ('\n', state) == EOF)
-	  return 0;
-    }
-
-  if (public->num_bad)
-    {
-      for (i = 0; i < public->num_bad; i++)
-	if (aiger_put_u (state, put, public->bad[i].lit) == EOF ||
-	    put ('\n', state) == EOF)
-	  return 0;
-    }
-
-  if (public->num_constraints)
-    {
-      for (i = 0; i < public->num_constraints; i++)
-	if (aiger_put_u (state, put, public->constraints[i].lit) == EOF ||
-	    put ('\n', state) == EOF)
-	  return 0;
-    }
-
-  if (public->num_justice)
-    {
-      for (i = 0; i < public->num_justice; i++)
-	{
-	  if (aiger_put_u (state, put, public->justice[i].size) == EOF)
-	    return 0;
-	  if (put ('\n', state) == EOF) return 0;
-	}
-
-      for (i = 0; i < public->num_justice; i++)
-	{
-	  for (j = 0; j < public->justice[i].size; j++)
-	    {
-	      if (aiger_put_u (state, put, public->justice[i].lits[j]) == EOF)
-	        return 0;
-	      if (put ('\n', state) == EOF) return 0;
-	    }
-	}
-    }
-
-  if (public->num_fairness)
-    {
-      for (i = 0; i < public->num_fairness; i++)
-	if (aiger_put_u (state, put, public->fairness[i].lit) == EOF ||
-	    put ('\n', state) == EOF)
-	  return 0;
-    }
-
-  return 1;
-}
-
-static int
-aiger_have_at_least_one_symbol_aux (aiger * public,
-				    aiger_symbol * symbols, unsigned size)
-{
-  unsigned i;
-
-  for (i = 0; i < size; i++)
-    if (symbols[i].name)
-      return 1;
-
-  return 0;
-}
-
-static int
-aiger_have_at_least_one_symbol (aiger * public)
-{
-  if (aiger_have_at_least_one_symbol_aux (public,
-					  public->inputs, public->num_inputs))
-    return 1;
-
-  if (aiger_have_at_least_one_symbol_aux (public,
-					  public->outputs,
-					  public->num_outputs))
-    return 1;
-
-  if (aiger_have_at_least_one_symbol_aux (public,
-					  public->latches,
-					  public->num_latches))
-    return 1;
-
-  if (aiger_have_at_least_one_symbol_aux (public,
-					  public->bad,
-					  public->num_bad))
-    return 1;
-
-  if (aiger_have_at_least_one_symbol_aux (public,
-					  public->constraints,
-					  public->num_constraints))
-    return 1;
-
-  if (aiger_have_at_least_one_symbol_aux (public,
-					  public->justice,
-					  public->num_justice))
-    return 1;
-
-  if (aiger_have_at_least_one_symbol_aux (public,
-					  public->fairness,
-					  public->num_fairness))
-    return 1;
-
-  return 0;
-}
-
-static int
-aiger_write_symbols_aux (aiger * public,
-			 void *state, aiger_put put,
-			 const char *type,
-			 aiger_symbol * symbols, unsigned size)
-{
-  unsigned i;
-
-  for (i = 0; i < size; i++)
-    {
-      if (!symbols[i].name)
-	continue;
-
-      assert (symbols[i].name[0]);
-
-      if (aiger_put_s (state, put, type) == EOF ||
-	  aiger_put_u (state, put, i) == EOF ||
-	  put (' ', state) == EOF ||
-	  aiger_put_s (state, put, symbols[i].name) == EOF ||
-	  put ('\n', state) == EOF)
-	return 0;
-    }
-
-  return 1;
-}
-
-static int
-aiger_write_symbols (aiger * public, void *state, aiger_put put)
-{
-  if (!aiger_write_symbols_aux (public, state, put,
-				"i", public->inputs, public->num_inputs))
-    return 0;
-
-  if (!aiger_write_symbols_aux (public, state, put,
-				"l", public->latches, public->num_latches))
-    return 0;
-
-  if (!aiger_write_symbols_aux (public, state, put,
-				"o", public->outputs, public->num_outputs))
-    return 0;
-
-  if (!aiger_write_symbols_aux (public, state, put,
-				"b", public->bad, public->num_bad))
-    return 0;
-
-  if (!aiger_write_symbols_aux (public, state, put,
-				"c", public->constraints,
-				public->num_constraints))
-    return 0;
-
-  if (!aiger_write_symbols_aux (public, state, put,
-				"j", public->justice, public->num_justice))
-    return 0;
-
-  if (!aiger_write_symbols_aux (public, state, put,
-				"f", public->fairness, public->num_fairness))
-    return 0;
-
-  return 1;
-}
-
-int
-aiger_write_symbols_to_file (aiger * public, FILE * file)
-{
-  assert (!aiger_error (public));
-  return aiger_write_symbols (public, file, (aiger_put) aiger_default_put);
-}
-
-static int
-aiger_write_comments (aiger * public, void *state, aiger_put put)
-{
-  char **p, *str;
-
-  for (p = public->comments; (str = *p); p++)
-    {
-      if (aiger_put_s (state, put, str) == EOF)
-	return 0;
-
-      if (put ('\n', state) == EOF)
-	return 0;
-    }
-
-  return 1;
-}
-
-int
-aiger_write_comments_to_file (aiger * public, FILE * file)
-{
-  assert (!aiger_error (public));
-  return aiger_write_comments (public, file, (aiger_put) aiger_default_put);
-}
-
-static int
-aiger_write_ascii (aiger * public, void *state, aiger_put put)
-{
-  aiger_and *and;
-  unsigned i;
-
-  assert (!aiger_check (public));
-
-  if (!aiger_write_header (public, "aag", 0, state, put))
-    return 0;
-
-  for (i = 0; i < public->num_ands; i++)
-    {
-      and = public->ands + i;
-      if (aiger_put_u (state, put, and->lhs) == EOF ||
-	  put (' ', state) == EOF ||
-	  aiger_put_u (state, put, and->rhs0) == EOF ||
-	  put (' ', state) == EOF ||
-	  aiger_put_u (state, put, and->rhs1) == EOF ||
-	  put ('\n', state) == EOF)
-	return 0;
-    }
-
-  return 1;
-}
-
-static unsigned
-aiger_max_input_or_latch (aiger * public)
-{
-  unsigned i, tmp, res;
-
-  res = 0;
-
-  for (i = 0; i < public->num_inputs; i++)
-    {
-      tmp = public->inputs[i].lit;
-      assert (!aiger_sign (tmp));
-      if (tmp > res)
-	res = tmp;
-    }
-
-  for (i = 0; i < public->num_latches; i++)
-    {
-      tmp = public->latches[i].lit;
-      assert (!aiger_sign (tmp));
-      if (tmp > res)
-	res = tmp;
-    }
-
-  return res;
-}
-
-int
-aiger_is_reencoded (aiger * public)
-{
-  unsigned i, tmp, max, lhs;
-  aiger_and *and;
-
-  max = 0;
-  for (i = 0; i < public->num_inputs; i++)
-    {
-      max += 2;
-      tmp = public->inputs[i].lit;
-      if (max != tmp)
-	return 0;
-    }
-
-  for (i = 0; i < public->num_latches; i++)
-    {
-      max += 2;
-      tmp = public->latches[i].lit;
-      if (max != tmp)
-	return 0;
-    }
-
-  lhs = aiger_max_input_or_latch (public) + 2;
-  for (i = 0; i < public->num_ands; i++)
-    {
-      and = public->ands + i;
-
-      if (and->lhs <= max)
-	return 0;
-
-      if (and->lhs != lhs)
-	return 0;
-
-      if (and->lhs < and->rhs0)
-	return 0;
-
-      if (and->rhs0 < and->rhs1)
-	return 0;
-
-      lhs += 2;
-    }
-
-  return 1;
-}
-
-static void
-aiger_new_code (unsigned var, unsigned *new, unsigned *code)
-{
-  unsigned lit = aiger_var2lit (var), res;
-  assert (!code[lit]);
-  res = *new;
-  code[lit] = res;
-  code[lit + 1] = res + 1;
-  *new += 2;
-}
-
-static unsigned
-aiger_reencode_lit (aiger * public, unsigned lit,
-		    unsigned *new, unsigned *code,
-		    unsigned **stack_ptr, unsigned * size_stack_ptr)
-{
-  unsigned res, old, top, child0, child1, tmp, var, size_stack, * stack;
-  IMPORT_private_FROM (public);
-  aiger_type *type;
-  aiger_and *and;
-
-  if (lit < 2)
-    return lit;
-
-  res = code[lit];
-  if (res)
-    return res;
-
-  var = aiger_lit2var (lit);
-  assert (var <= public->maxvar);
-  type = private->types + var;
-
-  if (type->and)
-    {
-      top = 0;
-      stack = *stack_ptr;
-      size_stack = *size_stack_ptr;
-      PUSH (stack, top, size_stack, var);
-
-      while (top > 0)
-	{
-	  old = stack[--top];
-	  if (old)
-	    {
-	      if (code[aiger_var2lit (old)])
-		continue;
-
-	      assert (old <= public->maxvar);
-	      type = private->types + old;
-	      if (type->onstack)
-		continue;
-
-	      type->onstack = 1;
-
-	      PUSH (stack, top, size_stack, old);
-	      PUSH (stack, top, size_stack, 0);
-
-	      assert (type->and);
-	      assert (type->idx < public->num_ands);
-
-	      and = public->ands + type->idx;
-	      assert (and);
-
-	      child0 = aiger_lit2var (and->rhs0);
-	      child1 = aiger_lit2var (and->rhs1);
-
-	      if (child0 < child1)
-		{
-		  tmp = child0;
-		  child0 = child1;
-		  child1 = tmp;
-		}
-
-	      assert (child0 >= child1);	/* smaller child first */
-
-	      if (child0)
-		{
-		  type = private->types + child0;
-		  if (!type->input && !type->latch && !type->onstack)
-		    PUSH (stack, top, size_stack, child0);
-		}
-
-	      if (child1)
-		{
-		  type = private->types + child1;
-		  if (!type->input && !type->latch && !type->onstack)
-		    PUSH (stack, top, size_stack, child1);
-		}
-	    }
-	  else
-	    {
-	      assert (top > 0);
-	      old = stack[--top];
-	      assert (!code[aiger_var2lit (old)]);
-	      type = private->types + old;
-	      assert (type->onstack);
-	      type->onstack = 0;
-	      aiger_new_code (old, new, code);
-	    }
-	}
-      *size_stack_ptr = size_stack;
-      *stack_ptr = stack;
-    }
-  else
-    {
-      assert (type->input || type->latch);
-      assert (lit < *new);
-
-      code[lit] = lit;
-      code[aiger_not (lit)] = aiger_not (lit);
-    }
-
-  assert (code[lit]);
-
-  return code[lit];
-}
-
-static int
-cmp_lhs (const void *a, const void *b)
-{
-  const aiger_and *c = a;
-  const aiger_and *d = b;
-  return ((int) c->lhs) - (int) d->lhs;
-}
-
-void
-aiger_reencode (aiger * public)
-{
-  unsigned *code, i, j, size_code, old, new, lhs, rhs0, rhs1, tmp;
-  unsigned *stack, size_stack;
-  IMPORT_private_FROM (public);
-
-  assert (!aiger_error (public));
-
-  aiger_symbol *symbol;
-  aiger_type *type;
-  aiger_and *and;
-
-  if (aiger_is_reencoded (public))
-    return;
-
-  size_code = 2 * (public->maxvar + 1);
-  if (size_code < 2)
-    size_code = 2;
-
-  NEWN (code, size_code);
-
-  code[1] = 1;			/* not used actually */
-
-  new = 2;
-
-  for (i = 0; i < public->num_inputs; i++)
-    {
-      old = public->inputs[i].lit;
-
-      code[old] = new;
-      code[old + 1] = new + 1;
-
-      new += 2;
-    }
-
-  for (i = 0; i < public->num_latches; i++)
-    {
-      old = public->latches[i].lit;
-
-      code[old] = new;
-      code[old + 1] = new + 1;
-
-      new += 2;
-    }
-
-  stack = 0;
-  size_stack = 0;
-
-  for (i = 0; i < public->num_latches; i++)
-    {
-      old = public->latches[i].next;
-      public->latches[i].next =
-	aiger_reencode_lit (public, old, &new, code, &stack, &size_stack);
-
-      old = public->latches[i].reset;
-      public->latches[i].reset =
-	aiger_reencode_lit (public, old, &new, code, &stack, &size_stack);
-    }
-
-  for (i = 0; i < public->num_outputs; i++)
-    {
-      old = public->outputs[i].lit;
-      public->outputs[i].lit =
-	aiger_reencode_lit (public, old, &new, code, &stack, &size_stack);
-    }
-
-  for (i = 0; i < public->num_bad; i++)
-    {
-      old = public->bad[i].lit;
-      public->bad[i].lit =
-	aiger_reencode_lit (public, old, &new, code, &stack, &size_stack);
-    }
-
-  for (i = 0; i < public->num_constraints; i++)
-    {
-      old = public->constraints[i].lit;
-      public->constraints[i].lit =
-	aiger_reencode_lit (public, old, &new, code, &stack, &size_stack);
-    }
-
-  for (i = 0; i < public->num_justice; i++)
-    {
-      for (j = 0; j < public->justice[i].size; j++)
-	{
-	  old = public->justice[i].lits[j];
-	  public->justice[i].lits[j] =
-	    aiger_reencode_lit (public, old, &new, code, &stack, &size_stack);
-	}
-    }
-
-  for (i = 0; i < public->num_fairness; i++)
-    {
-      old = public->fairness[i].lit;
-      public->fairness[i].lit =
-	aiger_reencode_lit (public, old, &new, code, &stack, &size_stack);
-    }
-
-  DELETEN (stack, size_stack);
-
-  j = 0;
-  for (i = 0; i < public->num_ands; i++)
-    {
-      and = public->ands + i;
-      lhs = code[and->lhs];
-      if (!lhs)
-	continue;
-
-      rhs0 = code[and->rhs0];
-      rhs1 = code[and->rhs1];
-
-      and = public->ands + j++;
-
-      if (rhs0 < rhs1)
-	{
-	  tmp = rhs1;
-	  rhs1 = rhs0;
-	  rhs0 = tmp;
-	}
-
-      assert (lhs > rhs0);
-      assert (rhs0 >= rhs1);
-
-      and->lhs = lhs;
-      and->rhs0 = rhs0;
-      and->rhs1 = rhs1;
-    }
-  public->num_ands = j;
-
-  qsort (public->ands, j, sizeof (*and), cmp_lhs);
-
-  /* Reset types.
-   */
-  for (i = 1; i <= public->maxvar; i++)
-    {
-      type = private->types + i;
-      type->input = 0;
-      type->latch = 0;
-      type->and = 0;
-      type->idx = 0;
-    }
-
-  assert (new);
-  assert (public->maxvar >= aiger_lit2var (new - 1));
-  public->maxvar = aiger_lit2var (new - 1);
-
-  /* Fix types for ANDs.
-   */
-  for (i = 0; i < public->num_ands; i++)
-    {
-      and = public->ands + i;
-      type = private->types + aiger_lit2var (and->lhs);
-      type->and = 1;
-      type->idx = i;
-    }
-
-  /* Fix types for inputs.
-   */
-  for (i = 0; i < public->num_inputs; i++)
-    {
-      symbol = public->inputs + i;
-      assert (symbol->lit < size_code);
-      symbol->lit = code[symbol->lit];
-      type = private->types + aiger_lit2var (symbol->lit);
-      type->input = 1;
-      type->idx = i;
-    }
-
-  /* Fix types for latches.
-   */
-  for (i = 0; i < public->num_latches; i++)
-    {
-      symbol = public->latches + i;
-      symbol->lit = code[symbol->lit];
-      type = private->types + aiger_lit2var (symbol->lit);
-      type->latch = 1;
-      type->idx = i;
-    }
-
-  DELETEN (code, size_code);
-
-#ifndef NDEBUG
-  for (i = 0; i <= public->maxvar; i++)
-    {
-      type = private->types + i;
-      assert (!(type->input && type->latch));
-      assert (!(type->input && type->and));
-      assert (!(type->latch && type->and));
-    }
-#endif
-  assert (aiger_is_reencoded (public));
-  assert (!aiger_check (public));
-}
-
-const unsigned char *
-aiger_coi (aiger * public)
-{
-  IMPORT_private_FROM (public);
-  private->size_coi = public->maxvar + 1;
-  NEWN (private->coi, private->size_coi);
-  memset (private->coi, 1, private->size_coi);
-  return private->coi;
-}
-
-static int
-aiger_write_binary (aiger * public, void *state, aiger_put put)
-{
-  aiger_and *and;
-  unsigned lhs, i;
-
-  assert (!aiger_check (public));
-
-  aiger_reencode (public);
-
-  if (!aiger_write_header (public, "aig", 1, state, put))
-    return 0;
-
-  lhs = aiger_max_input_or_latch (public) + 2;
-
-  for (i = 0; i < public->num_ands; i++)
-    {
-      and = public->ands + i;
-
-      assert (lhs == and->lhs);
-      assert (lhs > and->rhs0);
-      assert (and->rhs0 >= and->rhs1);
-
-      if (!aiger_write_delta (state, put, lhs - and->rhs0))
-	return 0;
-
-      if (!aiger_write_delta (state, put, and->rhs0 - and->rhs1))
-	return 0;
-
-      lhs += 2;
-    }
-
-  return 1;
-}
-
-unsigned
-aiger_strip_symbols_and_comments (aiger * public)
-{
-  IMPORT_private_FROM (public);
-  unsigned res;
-
-  assert (!aiger_error (public));
-
-  res = aiger_delete_comments (public);
-
-  res += aiger_delete_symbols_aux (private,
-				   public->inputs,
-				   private->size_inputs);
-  res += aiger_delete_symbols_aux (private,
-				   public->latches,
-				   private->size_latches);
-  res += aiger_delete_symbols_aux (private,
-				   public->outputs,
-				   private->size_outputs);
-  res += aiger_delete_symbols_aux (private,
-				   public->bad, 
-				   private->size_bad);
-  res += aiger_delete_symbols_aux (private,
-				   public->constraints,
-				   private->size_constraints);
-  res += aiger_delete_symbols_aux (private,
-				   public->justice,
-				   private->size_justice);
-  res += aiger_delete_symbols_aux (private,
-				   public->fairness,
-				   private->size_fairness);
-  return res;
-}
-
-int
-aiger_write_generic (aiger * public,
-		     aiger_mode mode, void *state, aiger_put put)
-{
-  assert (!aiger_error (public));
-
-  if ((mode & aiger_ascii_mode))
-    {
-      if (!aiger_write_ascii (public, state, put))
-	return 0;
-    }
-  else
-    {
-      if (!aiger_write_binary (public, state, put))
-	return 0;
-    }
-
-  if (!(mode & aiger_stripped_mode))
-    {
-      if (aiger_have_at_least_one_symbol (public))
-	{
-	  if (!aiger_write_symbols (public, state, put))
-	    return 0;
-	}
-
-      if (public->comments[0])
-	{
-	  if (aiger_put_s (state, put, "c\n") == EOF)
-	    return 0;
-
-	  if (!aiger_write_comments (public, state, put))
-	    return 0;
-	}
-    }
-
-  return 1;
-}
-
-int
-aiger_write_to_file (aiger * public, aiger_mode mode, FILE * file)
-{
-  assert (!aiger_error (public));
-  return aiger_write_generic (public,
-			      mode, file, (aiger_put) aiger_default_put);
-}
-
-int
-aiger_write_to_string (aiger * public, aiger_mode mode, char *str, size_t len)
-{
-  aiger_buffer buffer;
-  int res;
-
-  assert (!aiger_error (public));
-
-  buffer.start = str;
-  buffer.cursor = str;
-  buffer.end = str + len;
-  res = aiger_write_generic (public,
-			     mode, &buffer, (aiger_put) aiger_string_put);
-
-  if (!res)
-    return 0;
-
-  if (aiger_string_put (0, &buffer) == EOF)
-    return 0;
-
-  return 1;
-}
-
-static int
-aiger_has_suffix (const char *str, const char *suffix)
-{
-  if (strlen (str) < strlen (suffix))
-    return 0;
-
-  return !strcmp (str + strlen (str) - strlen (suffix), suffix);
-}
-
-int
-aiger_open_and_write_to_file (aiger * public, const char *file_name)
-{
-  IMPORT_private_FROM (public);
-  int res, pclose_file;
-  char *cmd, size_cmd;
-  aiger_mode mode;
-  FILE *file;
-
-  assert (!aiger_error (public));
-
-  assert (file_name);
-
-  if (aiger_has_suffix (file_name, ".gz"))
-    {
-      size_cmd = strlen (file_name) + strlen (GZIP);
-      NEWN (cmd, size_cmd);
-      sprintf (cmd, GZIP, file_name);
-      file = popen (cmd, "w");
-      DELETEN (cmd, size_cmd);
-      pclose_file = 1;
-    }
-  else
-    {
-      file = fopen (file_name, "w");
-      pclose_file = 0;
-    }
-
-  if (!file)
-    return 0;
-
-  if (aiger_has_suffix (file_name, ".aag") ||
-      aiger_has_suffix (file_name, ".aag.gz"))
-    mode = aiger_ascii_mode;
-  else
-    mode = aiger_binary_mode;
-
-  res = aiger_write_to_file (public, mode, file);
-
-  if (pclose_file)
-    pclose (file);
-  else
-    fclose (file);
-
-  if (!res)
-    unlink (file_name);
-
-  return res;
-}
-
-static int
-aiger_next_ch (aiger_reader * reader)
-{
-  int res;
-
-  res = reader->get (reader->state);
-
-  if (isspace (reader->ch) && !isspace (res))
-    reader->lineno_at_last_token_start = reader->lineno;
-
-  reader->ch = res;
-
-  if (reader->done_with_reading_header && reader->looks_like_aag)
-    {
-      if (!isspace (res) && !isdigit (res) && res != EOF)
-	reader->looks_like_aag = 0;
-    }
-
-  if (res == '\n')
-    reader->lineno++;
-
-  if (res != EOF)
-    reader->charno++;
-
-  return res;
-}
-
-/* Read a number assuming that the current character has already been
- * checked to be a digit, e.g. the start of the number to be read.
- */
-static unsigned
-aiger_read_number (aiger_reader * reader)
-{
-  unsigned res;
-
-  assert (isdigit (reader->ch));
-  res = reader->ch - '0';
-
-  while (isdigit (aiger_next_ch (reader)))
-    res = 10 * res + (reader->ch - '0');
-
-  return res;
-}
-
-/* Expect and read an unsigned number followed by at least one white space
- * character.  The white space should either the space character or a new
- * line as specified by the 'followed_by' parameter.  If a number can not be
- * found or there is no white space after the number, an apropriate error
- * message is returned.
- */
-static const char *
-aiger_read_literal (aiger_private * private,
-		    aiger_reader * reader,
-		    const char * context,
-		    unsigned *res_ptr, 
-		    char expected_followed_by,
-		    char * followed_by_ptr)
-{
-  unsigned res;
-
-  assert (expected_followed_by == ' ' || 
-          expected_followed_by == '\n' ||
-          !expected_followed_by);
-
-  if (!isdigit (reader->ch))
-    return aiger_error_us (private,
-			  "line %u: expected %s",
-			  reader->lineno, context);
-
-  res = aiger_read_number (reader);
-
-  if (expected_followed_by == ' ')
-    {
-      if (reader->ch != ' ')
-	return aiger_error_usu (private,
-		 "line %u: expected space after %s %u",
-		 reader->lineno_at_last_token_start, context, res);
-}
-  if (expected_followed_by == '\n')
-    {
-      if (reader->ch != '\n')
-	return aiger_error_usu (private,
-		 "line %u: expected new line after %s %u",
-		 reader->lineno_at_last_token_start, context, res);
-}
-  if (!expected_followed_by)
-    {
-      if (reader->ch != '\n' && reader->ch != ' ')
-	return aiger_error_usu (private,
-		 "line %u: expected space or new line after %s %u",
-		 reader->lineno_at_last_token_start, context, res);
-    }
-
-  if (followed_by_ptr)
-    *followed_by_ptr = reader->ch;
-
-  aiger_next_ch (reader);	/* skip white space */
-
-  *res_ptr = res;
-
-  return 0;
-}
-
-static const char *
-aiger_already_defined (aiger * public, aiger_reader * reader, unsigned lit)
-{
-  IMPORT_private_FROM (public);
-  aiger_type *type;
-  unsigned var;
-
-  assert (lit);
-  assert (!aiger_sign (lit));
-
-  var = aiger_lit2var (lit);
-
-  if (public->maxvar < var)
-    return 0;
-
-  type = private->types + var;
-
-  if (type->input)
-    return aiger_error_uu (private,
-			   "line %u: literal %u already defined as input",
-			   reader->lineno_at_last_token_start, lit);
-
-  if (type->latch)
-    return aiger_error_uu (private,
-			   "line %u: literal %u already defined as latch",
-			   reader->lineno_at_last_token_start, lit);
-
-  if (type->and)
-    return aiger_error_uu (private,
-			   "line %u: literal %u already defined as AND",
-			   reader->lineno_at_last_token_start, lit);
-  return 0;
-}
-
-static const char *
-aiger_read_header (aiger * public, aiger_reader * reader)
-{
-  IMPORT_private_FROM (public);
-  unsigned i, j, lit, next, reset;
-  unsigned * sizes, * lits;
-  const char *error;
-  char ch;
-
-  aiger_next_ch (reader);
-  if (reader->ch != 'a')
-    return aiger_error_u (private,
-			  "line %u: expected 'a' as first character",
-			  reader->lineno);
-
-  if (aiger_next_ch (reader) != 'i' && reader->ch != 'a')
-    return aiger_error_u (private,
-			  "line %u: expected 'i' or 'a' after 'a'",
-			  reader->lineno);
-
-  if (reader->ch == 'a')
-    reader->mode = aiger_ascii_mode;
-  else
-    reader->mode = aiger_binary_mode;
-
-  if (aiger_next_ch (reader) != 'g')
-    return aiger_error_u (private,
-			  "line %u: expected 'g' after 'a[ai]'",
-			  reader->lineno);
-
-  if (aiger_next_ch (reader) != ' ')
-    return aiger_error_u (private,
-			  "line %u: expected ' ' after 'a[ai]g'",
-			  reader->lineno);
-
-  aiger_next_ch (reader);
-
-  if (aiger_read_literal (private, reader,
-        "maximum variable index", &reader->maxvar, ' ', 0) ||
-      aiger_read_literal (private, reader,
-        "number of inputs", &reader->inputs, ' ', 0) ||
-      aiger_read_literal (private, reader,
-        "number latches", &reader->latches, ' ', 0) ||
-      aiger_read_literal (private, reader,
-        "number of outputs", &reader->outputs, ' ', 0) ||
-      aiger_read_literal (private, reader,
-        "number of and gates", &reader->ands, 0, &ch) ||
-      (ch == ' ' &&
-       aiger_read_literal (private, reader,
-         "number of bad state constraints", &reader->bad, 0, &ch)) ||
-      (ch == ' ' &&
-       aiger_read_literal (private, reader,
-         "number of invariant constraints",
-	 &reader->constraints, 0, &ch)) ||
-      (ch == ' ' &&
-       aiger_read_literal (private, reader,
-         "number of justice constraints", &reader->justice, 0, &ch)) ||
-      (ch == ' ' &&
-       aiger_read_literal (private, reader,
-         "number of fairness constraints", &reader->fairness, '\n', 0)))
-    {
-      assert (private->error);
-      return private->error;
-    }
-
-  if (reader->mode == aiger_binary_mode)
-    {
-      i = reader->inputs;
-      i += reader->latches;
-      i += reader->ands;
-
-      if (i != reader->maxvar)
-	return aiger_error_u (private,
-			      "line %u: invalid maximal variable index",
-			      reader->lineno);
-    }
-
-  public->maxvar = reader->maxvar;
-
-  FIT (private->types, private->size_types, public->maxvar + 1);
-  FIT (public->inputs, private->size_inputs, reader->inputs);
-  FIT (public->latches, private->size_latches, reader->latches);
-  FIT (public->outputs, private->size_outputs, reader->outputs);
-  FIT (public->ands, private->size_ands, reader->ands);
-  FIT (public->bad, private->size_bad, reader->bad);
-  FIT (public->constraints, private->size_constraints, reader->constraints);
-  FIT (public->justice, private->size_justice, reader->justice);
-  FIT (public->fairness, private->size_fairness, reader->fairness);
-
-  for (i = 0; i < reader->inputs; i++)
-    {
-      if (reader->mode == aiger_ascii_mode)
-	{
-	  error = aiger_read_literal (private, reader,
-	            "input literal", &lit, '\n', 0);
-	  if (error)
-	    return error;
-
-	  if (!lit || aiger_sign (lit)
-	      || aiger_lit2var (lit) > public->maxvar)
-	    return aiger_error_uu (private,
-				   "line %u: literal %u is not a valid input",
-				   reader->lineno_at_last_token_start, lit);
-
-	  error = aiger_already_defined (public, reader, lit);
-	  if (error)
-	    return error;
-	}
-      else
-	lit = 2 * (i + 1);
-
-      aiger_add_input (public, lit, 0);
-    }
-
-  for (i = 0; i < reader->latches; i++)
-    {
-      if (reader->mode == aiger_ascii_mode)
-	{
-	  error = aiger_read_literal (private, reader,
-	            "latch literal", &lit, ' ', 0);
-	  if (error)
-	    return error;
-
-	  if (!lit || aiger_sign (lit)
-	      || aiger_lit2var (lit) > public->maxvar)
-	    return aiger_error_uu (private,
-				   "line %u: literal %u is not a valid latch",
-				   reader->lineno_at_last_token_start, lit);
-
-	  error = aiger_already_defined (public, reader, lit);
-	  if (error)
-	    return error;
-	}
-      else
-	lit = 2 * (i + reader->inputs + 1);
-
-      error = aiger_read_literal (private, reader,
-                "next state literal", &next, 0, &ch);
-      if (error)
-	return error;
-
-      if (aiger_lit2var (next) > public->maxvar)
-	return aiger_error_uu (private,
-			       "line %u: literal %u is not a valid literal",
-			       reader->lineno_at_last_token_start, next);
-
-      aiger_add_latch (public, lit, next, 0);
-
-      if (ch == ' ')
-	{
-	  error = aiger_read_literal (private, reader,
-	            "reset literal", &reset, '\n', 0);
-	  if (error)
-	    return error;
-
-	  aiger_add_reset (public, lit, reset);
-	}
-    }
-
-  for (i = 0; i < reader->outputs; i++)
-    {
-      error = aiger_read_literal (private, reader,
-                "output literal", &lit, '\n', 0);
-      if (error)
-	return error;
-
-      if (aiger_lit2var (lit) > public->maxvar)
-	return aiger_error_uu (private,
-			       "line %u: literal %u is not a valid output",
-			       reader->lineno_at_last_token_start, lit);
-
-      aiger_add_output (public, lit, 0);
-    }
-
-  for (i = 0; i < reader->bad; i++)
-    {
-      error = aiger_read_literal (private, reader,
-                "bad state constraint literal", &lit, '\n', 0);
-      if (error)
-	return error;
-
-      if (aiger_lit2var (lit) > public->maxvar)
-	return aiger_error_uu (private,
-			       "line %u: literal %u is not valid bad",
-			       reader->lineno_at_last_token_start, lit);
-
-      aiger_add_bad (public, lit, 0);
-    }
-
-  for (i = 0; i < reader->constraints; i++)
-    {
-      error = aiger_read_literal (private, reader,
-                "invariant constraint literal", &lit, '\n', 0);
-      if (error)
-	return error;
-
-      if (aiger_lit2var (lit) > public->maxvar)
-	return aiger_error_uu (private,
-		 "line %u: literal %u is not a valid constraint",
-		 reader->lineno_at_last_token_start, lit);
-
-      aiger_add_constraint (public, lit, 0);
-    }
-
-  if (reader->justice)
-    {
-      NEWN (sizes, reader->justice);
-      error =  0;
-      for (i = 0; !error && i < reader->justice; i++)
-	error = aiger_read_literal (private, reader,
-	          "justice constraint size", sizes + i, '\n', 0);
-      for (i = 0; !error && i < reader->justice; i++)
-	{
-	  NEWN (lits, sizes[i]);
-	  for (j = 0; !error && j < sizes[i]; j++)
-	    error = aiger_read_literal (private, reader,
-	              "justice constraint literal", lits + j, '\n', 0);
-	  if (!error)
-	    aiger_add_justice (public, sizes[i], lits, 0);
-	  DELETEN (lits, sizes[i]);
-	}
-      DELETEN (sizes, reader->justice);
-      if (error)
-	return error;
-    }
-
-  for (i = 0; i < reader->fairness; i++)
-    {
-      error = aiger_read_literal (private, reader,
-                "fairness constraint literal", &lit, '\n', 0);
-      if (error)
-	return error;
-
-      if (aiger_lit2var (lit) > public->maxvar)
-	return aiger_error_uu (private,
-		 "line %u: literal %u is not valid fairness",
-		 reader->lineno_at_last_token_start, lit);
-
-      aiger_add_fairness (public, lit, 0);
-    }
-
-  reader->done_with_reading_header = 1;
-  reader->looks_like_aag = 1;
-
-  return 0;
-}
-
-static const char *
-aiger_read_ascii (aiger * public, aiger_reader * reader)
-{
-  IMPORT_private_FROM (public);
-  unsigned i, lhs, rhs0, rhs1;
-  const char *error;
-
-  for (i = 0; i < reader->ands; i++)
-    {
-      error = aiger_read_literal (private, reader,
-                "and gate left-hand side literal", &lhs, ' ', 0);
-      if (error)
-	return error;
-
-      if (!lhs || aiger_sign (lhs) || aiger_lit2var (lhs) > public->maxvar)
-	return aiger_error_uu (private,
-			       "line %u: "
-			       "literal %u is not a valid LHS of AND",
-			       reader->lineno_at_last_token_start, lhs);
-
-      error = aiger_already_defined (public, reader, lhs);
-      if (error)
-	return error;
-
-      error = aiger_read_literal (private, reader,
-                "and gate first right-hand side literal",
-		&rhs0, ' ', 0);
-      if (error)
-	return error;
-
-      if (aiger_lit2var (rhs0) > public->maxvar)
-	return aiger_error_uu (private,
-			       "line %u: literal %u is not a valid literal",
-			       reader->lineno_at_last_token_start, rhs0);
-
-      error = aiger_read_literal (private, reader,
-                "and gate first right-hand side literal",
-		&rhs1, '\n', 0);
-      if (error)
-	return error;
-
-      if (aiger_lit2var (rhs1) > public->maxvar)
-	return aiger_error_uu (private,
-			       "line %u: literal %u is not a valid literal",
-			       reader->lineno_at_last_token_start, rhs1);
-
-      aiger_add_and (public, lhs, rhs0, rhs1);
-    }
-
-  return 0;
-}
-
-static const char *
-aiger_read_delta (aiger_private * private, aiger_reader * reader,
-		  unsigned *res_ptr)
-{
-  unsigned res, i, charno;
-  unsigned char ch;
-
-  if (reader->ch == EOF)
-  UNEXPECTED_EOF:
-    return aiger_error_u (private,
-			  "character %u: unexpected end of file",
-			  reader->charno);
-  i = 0;
-  res = 0;
-  ch = reader->ch;
-
-  charno = reader->charno;
-
-  while ((ch & 0x80))
-    {
-      assert (sizeof (unsigned) == 4);
-
-      if (i == 5)
-      INVALID_CODE:
-	return aiger_error_u (private, "character %u: invalid code", charno);
-
-      res |= (ch & 0x7f) << (7 * i++);
-      aiger_next_ch (reader);
-      if (reader->ch == EOF)
-	goto UNEXPECTED_EOF;
-
-      ch = reader->ch;
-    }
-
-  if (i == 5 && ch >= 8)
-    goto INVALID_CODE;
-
-  res |= ch << (7 * i);
-  *res_ptr = res;
-
-  aiger_next_ch (reader);
-
-  return 0;
-}
-
-static const char *
-aiger_read_binary (aiger * public, aiger_reader * reader)
-{
-  unsigned i, lhs, rhs0, rhs1, delta, charno;
-  IMPORT_private_FROM (public);
-  const char *error;
-
-  delta = 0;			/* avoid warning with -O3 */
-
-  lhs = aiger_max_input_or_latch (public);
-
-  for (i = 0; i < reader->ands; i++)
-    {
-      lhs += 2;
-      charno = reader->charno;
-      error = aiger_read_delta (private, reader, &delta);
-      if (error)
-	return error;
-
-      if (delta > lhs)		/* can at most be the same */
-      INVALID_DELTA:
-	return aiger_error_u (private, "character %u: invalid delta", charno);
-
-      rhs0 = lhs - delta;
-
-      charno = reader->charno;
-      error = aiger_read_delta (private, reader, &delta);
-      if (error)
-	return error;
-
-      if (delta > rhs0)		/* can well be the same ! */
-	goto INVALID_DELTA;
-
-      rhs1 = rhs0 - delta;
-
-      aiger_add_and (public, lhs, rhs0, rhs1);
-    }
-
-  return 0;
-}
-
-static void
-aiger_reader_push_ch (aiger_private * private, aiger_reader * reader, char ch)
-{
-  PUSH (reader->buffer, reader->top_buffer, reader->size_buffer, ch);
-}
-
-static const char *
-aiger_read_comments (aiger * public, aiger_reader * reader)
-{
-  IMPORT_private_FROM (public);
-  assert( reader->ch == '\n' );
-
-  aiger_next_ch (reader);
-
-  while (reader->ch != EOF)
-    {
-      while (reader->ch != '\n')
-	{
-	  aiger_reader_push_ch (private, reader, reader->ch);
-	  aiger_next_ch (reader);
-
-	  if (reader->ch == EOF)
-	    return aiger_error_u (private,
-				  "line %u: new line after comment missing",
-				  reader->lineno);
-	}
-
-      aiger_next_ch (reader);
-      aiger_reader_push_ch (private, reader, 0);
-      aiger_add_comment (public, reader->buffer);
-      reader->top_buffer = 0;
-    }
-
-  return 0;
-}
-
-static const char *
-aiger_read_symbols_and_comments (aiger * public, aiger_reader * reader)
-{
-  IMPORT_private_FROM (public);
-  const char *error, *type_name, * type_pos;
-  unsigned pos, num, count;
-  aiger_symbol *symbol;
-  
-  assert (!reader->buffer);
-
-  for (count = 0;; count++)
-    {
-      if (reader->ch == EOF)
-	return 0;
-
-      if (reader->ch != 'i' && 
-	  reader->ch != 'l' && 
-	  reader->ch != 'o' &&
-	  reader->ch != 'b' &&
-	  reader->ch != 'c' &&
-	  reader->ch != 'j' &&
-	  reader->ch != 'f')
-	{
-	  if (reader->looks_like_aag)
-	    return aiger_error_u (private,
-				  "line %u: corrupted symbol table "
-				  "('aig' instead of 'aag' header?)",
-				  reader->lineno);
-	  return aiger_error_u (private,
-			        "line %u: expected '[cilobcjf]' or EOF",
-			        reader->lineno);
-	}
-
-      /* 'c' is a special case as it may be either the start of a comment, 
-	 or the start of a constraint symbol */
-      if (reader->ch == 'c')
-	{	  
-	  if (aiger_next_ch (reader) == '\n' )
-	    return aiger_read_comments(public, reader);
-
-	  type_name = "constraint";
-	  type_pos = "constraint";
-	  num = public->num_constraints;
-	  symbol = public->constraints;
-
-	  if (!num)
-	    return aiger_error_u (private,
-		     "line %u: "
-		     "unexpected invariance constraint symbol entry prefix 'c ' "
-		     "(comment sections start with 'c<new-line>' without space)",
-		     reader->lineno_at_last_token_start);
-	}
-      else 
-	{
-	  if (reader->ch == 'i')
-	    {
-	      type_name = "input";
-	      type_pos = "input";
-	      num = public->num_inputs;
-	      symbol = public->inputs;
-	    }
-	  else if (reader->ch == 'l')
-	    {
-	      type_name = "latch";
-	      type_pos = "latch";
-	      num = public->num_latches;
-	      symbol = public->latches;
-	    }
-	  else if (reader->ch == 'o')
-	    {
-	      type_name = "output";
-	      type_pos = "output";
-	      num = public->num_outputs;
-	      symbol = public->outputs;
-	    }
-	  else if (reader->ch == 'b')
-	    {
-	      type_name = "bad";
-	      type_pos = "bad";
-	      num = public->num_bad;
-	      symbol = public->bad;
-	    }     
-	  else if (reader->ch == 'j')
-	    {
-	      type_name = "justice";
-	      type_pos = "justice";
-	      num = public->num_justice;
-	      symbol = public->justice;
-	    }
-	  else
-	    {
-	      assert (reader->ch == 'f');
-	      type_name = "fairness";
-	      type_pos = "fairness";
-	      num = public->num_fairness;
-	      symbol = public->fairness;
-	    }
-
-	  aiger_next_ch (reader);
-	}
-
-      error = aiger_read_literal (private, reader,
-                type_pos, &pos, ' ', 0);
-      if (error)
-	return error;
-
-      if (pos >= num)
-	return aiger_error_usu (private,
-		 "line %u: "
-		 "%s symbol table entry position %u too large",
-		 reader->lineno_at_last_token_start, type_name, pos);
-
-      symbol += pos;
-
-      if (symbol->name)
-	return aiger_error_usu (private,
-				"line %u: %s literal %u has multiple symbols",
-				reader->lineno_at_last_token_start, type_name,
-				symbol->lit);
-
-      while (reader->ch != '\n' && reader->ch != EOF)
-	{
-	  aiger_reader_push_ch (private, reader, reader->ch);
-	  aiger_next_ch (reader);
-	}
-
-      if (reader->ch == EOF)
-	return aiger_error_u (private,
-			      "line %u: new line missing", reader->lineno);
-
-      assert (reader->ch == '\n');
-      aiger_next_ch (reader);
-
-      aiger_reader_push_ch (private, reader, 0);
-      symbol->name = aiger_copy_str (private, reader->buffer);
-      reader->top_buffer = 0;
-    }
-}
-
-const char *
-aiger_read_generic (aiger * public, void *state, aiger_get get)
-{
-  IMPORT_private_FROM (public);
-  aiger_reader reader;
-  const char *error;
-
-  assert (!aiger_error (public));
-
-  CLR (reader);
-
-  reader.lineno = 1;
-  reader.state = state;
-  reader.get = get;
-  reader.ch = ' ';
-
-  error = aiger_read_header (public, &reader);
-  if (error)
-    return error;
-
-  if (reader.mode == aiger_ascii_mode)
-    error = aiger_read_ascii (public, &reader);
-  else
-    error = aiger_read_binary (public, &reader);
-
-  if (error)
-    return error;
-
-  error = aiger_read_symbols_and_comments (public, &reader);
-
-  DELETEN (reader.buffer, reader.size_buffer);
-
-  if (error)
-    return error;
-
-  return aiger_check (public);
-}
-
-const char *
-aiger_read_from_file (aiger * public, FILE * file)
-{
-  assert (!aiger_error (public));
-  return aiger_read_generic (public, file, (aiger_get) aiger_default_get);
-}
-
-const char *
-aiger_open_and_read_from_file (aiger * public, const char *file_name)
-{
-  IMPORT_private_FROM (public);
-  char *cmd, size_cmd;
-  const char *res;
-  int pclose_file;
-  FILE *file;
-
-  assert (!aiger_error (public));
-
-  if (aiger_has_suffix (file_name, ".gz"))
-    {
-      size_cmd = strlen (file_name) + strlen (GUNZIP);
-      NEWN (cmd, size_cmd);
-      sprintf (cmd, GUNZIP, file_name);
-      file = popen (cmd, "r");
-      DELETEN (cmd, size_cmd);
-      pclose_file = 1;
-    }
-  else
-    {
-      file = fopen (file_name, "rb");
-      pclose_file = 0;
-    }
-
-  if (!file)
-    return aiger_error_s (private, "can not read '%s'", file_name);
-
-  res = aiger_read_from_file (public, file);
-
-  if (pclose_file)
-    pclose (file);
-  else
-    fclose (file);
-
-  return res;
-}
-
-const char *
-aiger_get_symbol (aiger * public, unsigned lit)
-{
-  IMPORT_private_FROM (public);
-  aiger_symbol *symbol;
-  aiger_type *type;
-  unsigned var;
-
-  assert (!aiger_error (public));
-
-  assert (lit);
-  assert (!aiger_sign (lit));
-
-  var = aiger_lit2var (lit);
-  assert (var <= public->maxvar);
-  type = private->types + var;
-
-  if (type->input)
-    symbol = public->inputs;
-  else if (type->latch)
-    symbol = public->latches;
-  else
-    return 0;
-
-  return symbol[type->idx].name;
-}
-
-static aiger_type *
-aiger_lit2type (aiger * public, unsigned lit)
-{
-  IMPORT_private_FROM (public);
-  aiger_type *type;
-  unsigned var;
-
-  var = aiger_lit2var (lit);
-  assert (var <= public->maxvar);
-  type = private->types + var;
-
-  return type;
-}
-
-int
-aiger_lit2tag (aiger * public, unsigned lit) 
-{
-  aiger_type * type;
-  lit = aiger_strip (lit);
-  if (!lit) return 0;
-  type = aiger_lit2type (public, lit);
-  if (type->input) return 1;
-  if (type->latch) return 2;
-  return 3;
-}
-
-aiger_symbol *
-aiger_is_input (aiger * public, unsigned lit)
-{
-  aiger_type *type;
-  aiger_symbol *res;
-
-  assert (!aiger_error (public));
-  type = aiger_lit2type (public, lit);
-  if (!type->input)
-    return 0;
-
-  res = public->inputs + type->idx;
-
-  return res;
-}
-
-aiger_symbol *
-aiger_is_latch (aiger * public, unsigned lit)
-{
-  aiger_symbol *res;
-  aiger_type *type;
-
-  assert (!aiger_error (public));
-  type = aiger_lit2type (public, lit);
-  if (!type->latch)
-    return 0;
-
-  res = public->latches + type->idx;
-
-  return res;
-}
-
-aiger_and *
-aiger_is_and (aiger * public, unsigned lit)
-{
-  aiger_type *type;
-  aiger_and *res;
-
-  assert (!aiger_error (public));
-  type = aiger_lit2type (public, lit);
-  if (!type->and)
-    return 0;
-
-  res = public->ands + type->idx;
-
-  return res;
-}
diff --git a/aiger.h b/aiger.h
deleted file mode 100644
index 84437fb..0000000
--- a/aiger.h
+++ /dev/null
@@ -1,359 +0,0 @@
-/***************************************************************************
-Copyright (c) 2006 - 2018, Armin Biere, Johannes Kepler University.
-
-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.
-***************************************************************************/
-
-/*------------------------------------------------------------------------*/
-/* This file contains the API of the 'AIGER' library, which is a reader and
- * writer for the AIGER AIG format.  The code of the library 
- * consists of 'aiger.c' and 'aiger.h'.  It is independent of 'simpaig.c'
- * and 'simpaig.h'.
- * library.
- */
-#ifndef aiger_h_INCLUDED
-#define aiger_h_INCLUDED
-
-#include <stdio.h>
-
-/*------------------------------------------------------------------------*/
-
-#define AIGER_VERSION "1.9"
-
-/*------------------------------------------------------------------------*/
-
-typedef struct aiger aiger;
-typedef struct aiger_and aiger_and;
-typedef struct aiger_symbol aiger_symbol;
-
-/*------------------------------------------------------------------------*/
-/* AIG references are represented as unsigned integers and are called
- * literals.  The least significant bit is the sign.  The index of a literal
- * can be obtained by dividing the literal by two.  Only positive indices
- * are allowed, which leaves 0 for the boolean constant FALSE.  The boolean
- * constant TRUE is encoded as the unsigned number 1 accordingly.
- */
-#define aiger_false 0
-#define aiger_true 1
-
-#define aiger_is_constant(l) \
-  ((l) == aiger_false || ((l) == aiger_true))
-
-#define aiger_sign(l) \
-  (((unsigned)(l))&1)
-
-#define aiger_strip(l) \
-  (((unsigned)(l))&~1)
-
-#define aiger_not(l) \
-  (((unsigned)(l))^1)
-
-/*------------------------------------------------------------------------*/
-/* Each literal is associated to a variable having an unsigned index.  The
- * variable index is obtained by deviding the literal index by two, which is
- * the same as removing the sign bit.
- */
-#define aiger_var2lit(i) \
-  (((unsigned)(i)) << 1)
-
-#define aiger_lit2var(l) \
-  (((unsigned)(l)) >> 1)
-
-/*------------------------------------------------------------------------*/
-/* Callback functions for client memory management.  The 'free' wrapper will
- * get as last argument the size of the memory as it was allocated.
- */
-typedef void *(*aiger_malloc) (void *mem_mgr, size_t);
-typedef void (*aiger_free) (void *mem_mgr, void *ptr, size_t);
-
-/*------------------------------------------------------------------------*/
-/* Callback function for client character stream reading.  It returns an
- * ASCII character or EOF.  Thus is has the same semantics as the standard
- * library 'getc'.   See 'aiger_read_generic' for more details.
- */
-typedef int (*aiger_get) (void *client_state);
-
-/*------------------------------------------------------------------------*/
-/* Callback function for client character stream writing.  The return value
- * is EOF iff writing failed and otherwise the character 'ch' casted to an
- * unsigned char.  It has therefore the same semantics as 'fputc' and 'putc'
- * from the standard library.
- */
-typedef int (*aiger_put) (char ch, void *client_state);
-
-/*------------------------------------------------------------------------*/
-
-enum aiger_mode
-{
-  aiger_binary_mode = 0,
-  aiger_ascii_mode = 1,
-  aiger_stripped_mode = 2,	/* can be ORed with one of the previous */
-};
-
-typedef enum aiger_mode aiger_mode;
-
-/*------------------------------------------------------------------------*/
-
-struct aiger_and
-{
-  unsigned lhs;			/* as literal [2..2*maxvar], even */
-  unsigned rhs0;		/* as literal [0..2*maxvar+1] */
-  unsigned rhs1;		/* as literal [0..2*maxvar+1] */
-};
-
-/*------------------------------------------------------------------------*/
-
-struct aiger_symbol
-{
-  unsigned lit;			/* as literal [0..2*maxvar+1] */
-  unsigned next, reset;		/* used only for latches */
-  unsigned size, * lits;	/* used only for justice */
-  char *name;
-};
-
-/*------------------------------------------------------------------------*/
-/* This is the externally visible state of the library.  The format is
- * almost the same as the ASCII file format.  The first part is exactly as
- * in the header 'M I L O A' and optional 'B C J F' after the format identifier
- * string.
- */
-struct aiger
-{
-  /* variable not literal index, e.g. maxlit = 2*maxvar + 1 
-   */
-  unsigned maxvar;
-
-  unsigned num_inputs;
-  unsigned num_latches;
-  unsigned num_outputs;
-  unsigned num_ands;
-  unsigned num_bad;
-  unsigned num_constraints;
-  unsigned num_justice;
-  unsigned num_fairness;
-
-  aiger_symbol *inputs;		/* [0..num_inputs[ */
-  aiger_symbol *latches;	/* [0..num_latches[ */
-  aiger_symbol *outputs;	/* [0..num_outputs[ */
-  aiger_symbol *bad;		/* [0..num_bad[ */
-  aiger_symbol *constraints;	/* [0..num_constraints[ */
-  aiger_symbol *justice;	/* [0..num_justice[ */
-  aiger_symbol *fairness;	/* [0..num_fairness[ */
-
-  aiger_and *ands;		/* [0..num_ands[ */
-
-  char **comments;		/* zero terminated */
-};
-
-/*------------------------------------------------------------------------*/
-/* Version and CVS identifier.
- */
-const char *aiger_id (void);  	     /* not working after moving to 'git' */
-const char *aiger_version (void);
-
-/*------------------------------------------------------------------------*/
-/* You need to initialize the library first.  This generic initialization
- * function uses standard 'malloc' and 'free' from the standard library for
- * memory management.
- */
-aiger *aiger_init (void);
-
-/*------------------------------------------------------------------------*/
-/* Same as previous initialization function except that a memory manager
- * from the client is used for memory allocation.  See the 'aiger_malloc'
- * and 'aiger_free' definitions above.
- */
-aiger *aiger_init_mem (void *mem_mgr, aiger_malloc, aiger_free);
-
-/*------------------------------------------------------------------------*/
-/* Reset and delete the library.
- */
-void aiger_reset (aiger *);
-
-/*------------------------------------------------------------------------*/
-/* Treat the literal 'lit' as input, output, latch, bad, constraint,
- * justice of fairness respectively.  The
- * literal of latches and inputs can not be signed nor a constant (< 2).
- * You can not register latches nor inputs multiple times.  An input can not
- * be a latch.  The last argument is the symbolic name if non zero.
- * The same literal can of course be used for multiple outputs.
- */
-void aiger_add_input (aiger *, unsigned lit, const char *);
-void aiger_add_latch (aiger *, unsigned lit, unsigned next, const char *);
-void aiger_add_output (aiger *, unsigned lit, const char *);
-void aiger_add_bad (aiger *, unsigned lit, const char *);
-void aiger_add_constraint (aiger *, unsigned lit, const char *);
-void aiger_add_justice (aiger *, unsigned size, unsigned *, const char *);
-void aiger_add_fairness (aiger *, unsigned lit, const char *);
-
-/*------------------------------------------------------------------------*/
-/* Add a reset value to the latch 'lit'.  The 'lit' has to be a previously
- * added latch and 'reset' is either '0', '1' or equal to 'lit', the latter
- * means undefined.
- */
-void aiger_add_reset (aiger *, unsigned lit, unsigned reset);
-
-/*------------------------------------------------------------------------*/
-/* Register an unsigned AND with AIGER.  The arguments are signed literals
- * as discussed above, e.g. the least significant bit stores the sign and
- * the remaining bit the variable index.  The 'lhs' has to be unsigned
- * (even).  It identifies the AND and can only be registered once.  After
- * registration an AND can be accessed through 'ands[aiger_lit2idx (lhs)]'.
- */
-void aiger_add_and (aiger *, unsigned lhs, unsigned rhs0, unsigned rhs1);
-
-/*------------------------------------------------------------------------*/
-/* Add a line of comments.  The comment may not contain a new line character.
- */
-void aiger_add_comment (aiger *, const char *comment_line);
-
-/*------------------------------------------------------------------------*/
-/* This checks the consistency for debugging and testing purposes.  In
- * particular, it is checked that all 'next' literals of latches, all
- * outputs, and all right hand sides of ANDs are defined, where defined
- * means that the corresponding literal is a constant 0 or 1, or defined as
- * an input, a latch, or AND gate.  Furthermore the definitions of ANDs are
- * checked to be non cyclic.  If a check fails a corresponding error message
- * is returned.
- */
-const char *aiger_check (aiger *);
-
-/*------------------------------------------------------------------------*/
-/* These are the writer functions for AIGER.  They return zero on failure.
- * The assumptions on 'aiger_put' are the same as with 'fputc' from the
- * standard library (see the 'aiger_put' definition above).  Note, that
- * writing in binary mode triggers 'aig_reencode' and thus destroys the
- * original literal association and may even delete AND nodes.  See
- * 'aiger_reencode' for more details.
- */
-int aiger_write_to_file (aiger *, aiger_mode, FILE *);
-int aiger_write_to_string (aiger *, aiger_mode, char *str, size_t len);
-int aiger_write_generic (aiger *, aiger_mode, void *state, aiger_put);
-
-/*------------------------------------------------------------------------*/
-/* The following function allows to write to a file.  The write mode is
- * determined from the suffix in the file name.  The mode used is ASCII for
- * a '.aag' suffix and binary mode otherwise.  In addition a '.gz' suffix can
- * be added which requests the file to written by piping it through 'gzip'.
- * This feature assumes that the 'gzip' program is in your path and can be
- * executed through 'popen'.  The return value is non zero on success.
- */
-int aiger_open_and_write_to_file (aiger *, const char *file_name);
-
-/*------------------------------------------------------------------------*/
-/* The binary format reencodes all indices.  After normalization the input
- * indices come first followed by the latch and then the AND indices.  In
- * addition the indices will be topologically sorted to respect the
- * child/parent relation, e.g. child indices will always be smaller than
- * their parent indices.   This function can directly be called by the
- * client.  As a side effect, ANDs that are not in any cone of a next state
- * function nor in any cone of an output function are discarded.  The new
- * indices of ANDs start immediately after all input and latch indices.  The
- * data structures are updated accordingly including 'maxvar'.  The client
- * data within ANDs is reset to zero.
- */
-int aiger_is_reencoded (aiger *);
-void aiger_reencode (aiger *);
-
-/*------------------------------------------------------------------------*/
-/* This function computes the cone of influence (coi). The coi contains
- * those literals that may have an influence to one of the outputs.   A
- * variable 'v' is in the coi if the array returned as result is non zero at
- * position 'v'. All other variables can be considered redundant.  The array
- * returned is valid until the next call to this function and will be
- * deallocated on reset.
- *
- * TODO: this is just a stub and actually not really implemented yet.
- */
-const unsigned char * aiger_coi (aiger *);		/* [1..maxvar] */
-
-/*------------------------------------------------------------------------*/
-/* Read an AIG from a FILE, a string, or through a generic interface.  These
- * functions return a non zero error message if an error occurred and
- * otherwise 0.  The paramater 'aiger_get' has the same return values as
- * 'getc', e.g. it returns 'EOF' when done.  After an error occurred the
- * library becomes invalid.  Only 'aiger_reset' or 'aiger_error' can be
- * used.  The latter returns the previously returned error message.
- */
-const char *aiger_read_from_file (aiger *, FILE *);
-const char *aiger_read_from_string (aiger *, const char *str);
-const char *aiger_read_generic (aiger *, void *state, aiger_get);
-
-/*------------------------------------------------------------------------*/
-/* Returns a previously generated error message if the library is in an
- * invalid state.  After this function returns a non zero error message,
- * only 'aiger_reset' can be called (beside 'aiger_error').  The library can
- * reach an invalid through a failed read attempt, or if 'aiger_check'
- * failed.
- */
-const char *aiger_error (aiger *);
-
-/*------------------------------------------------------------------------*/
-/* Same semantics as with 'aiger_open_and_write_to_file' for reading.
- */
-const char *aiger_open_and_read_from_file (aiger *, const char *);
-
-/*------------------------------------------------------------------------*/
-/* Write symbol table or the comments to a file.  Result is zero on failure.
- */
-int aiger_write_symbols_to_file (aiger *, FILE * file);
-int aiger_write_comments_to_file (aiger *, FILE * file);
-
-/*------------------------------------------------------------------------*/
-/* Remove symbols and comments.  The result is the number of symbols
- * and comments removed.
- */
-unsigned aiger_strip_symbols_and_comments (aiger *);
-
-/*------------------------------------------------------------------------*/
-/* If 'lit' is an input or a latch with a name, the symbolic name is
- * returned.   Note, that literals can be used for multiple outputs.
- * Therefore there is no way to associate a name with a literal itself.
- * Names for outputs are stored in the 'outputs' symbols and can only be
- * accesed through a linear traversal of the output symbols.
- */
-const char *aiger_get_symbol (aiger *, unsigned lit);
-
-/*------------------------------------------------------------------------*/
-/* Return tag of the literal:
- *
- * 0 = constant
- * 1 = input
- * 2 = latch
- * 3 = and
- */
-
-int aiger_lit2tag (aiger *, unsigned lit);
-
-/*------------------------------------------------------------------------*/
-/* Check whether the given unsigned, e.g. even, literal was defined as
- * 'input', 'latch' or 'and'.  The command returns a zero pointer if the
- * literal was not defined as 'input', 'latch', or 'and' respectively.
- * Otherwise a pointer to the corresponding input or latch symbol is returned.
- * In the case of an 'and' the AND node is returned.  The returned symbol
- * if non zero is in the respective array of 'inputs', 'latches' and 'ands'.
- * It thus also allows to extract the position of an input or latch literal.
- * For outputs this is not possible, since the same literal may be used for
- * several outputs.
- */
-aiger_symbol *aiger_is_input (aiger *, unsigned lit);
-aiger_symbol *aiger_is_latch (aiger *, unsigned lit);
-aiger_and *aiger_is_and (aiger *, unsigned lit);
-
-#endif
diff --git a/circuit.cpp b/circuit.cpp
deleted file mode 100644
index c50d477..0000000
--- a/circuit.cpp
+++ /dev/null
@@ -1,449 +0,0 @@
-#include "sweep.hpp"
-#include "circuit.hpp"
-
-bool Sweep::match_xor(int x) { // check clause x, -y, -z <==> xor
-    int y = C[x][0], z = C[x][1];
-    if (y >= 0 || z >= 0) return false;
-    if (del[-y] || del[-z] || !C[-y].sz || !C[-z].sz) return false;
-    int u1 = C[-y][0], v1 = C[-y][1];
-    int u2 = C[-z][0], v2 = C[-z][1];
-    if (u1 == -u2 && v1 == -v2) goto doit;
-    if (u1 == -v2 && v1 == -u2) goto doit;
-    return false;
-doit:
-    del[x] = 1;
-    if (C[-y].outs <= 1) del[-y] = 2;
-    if (C[-z].outs <= 1) del[-z] = 2;
-    C[x][0] = C[-y][0], C[x][1] = C[-y][1];
-    C[x].type = Xor;
-
-    return true;
-}
-
-bool Sweep::match_majority(int x) {
-    // x = -y & z
-    // z = -v & -w
-    // y = a1 & a2
-    // v = a1 & a3
-    // w = a2 & a3
-    int y = C[x][0], z = C[x][1];
-    if (y > 0) std::swap(y, z);
-    if (y >= 0 || z <= 0) return false;
-    if (del[-y] || del[z] || !C[-y].sz || !C[z].sz) return false;
-    int v = C[z][0], w = C[z][1];
-    if (v >= 0 || w >= 0) return false;
-    if (del[-v] || del[-w] || !C[-v].sz || !C[-w].sz) return false;
-    // -y, -w, -v
-    int a = C[-y][0], b = C[-y][1];
-    if (C[-v][1] == a || C[-v][1] == b) std::swap(C[-v][0], C[-v][1]);
-    if (C[-w][1] == a || C[-w][1] == b) std::swap(C[-w][0], C[-w][1]);
-    if (C[-v][0] != a && C[-w][0] != a) return false;
-    if (C[-v][0] != b && C[-w][0] != b) return false;
-    if (C[-v][1] != C[-w][1]) return false;
-    del[x] = 1;
-    if (C[-y].outs <= 1) del[-y] = 2;
-    if (C[z].outs <= 1) del[z] = 2;
-    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].type = Majority;
-    return true;
-}
-
-void Sweep::adjust_not() {
-    int *pos = new int[maxvar + 1];
-    int *neg = new int[maxvar + 1];
-    for (int i = 1; i <= maxvar; i++)
-        pos[i] = neg[i] = 0; 
-    for (int i = 1; i <= maxvar; i++) {
-        if (!C[i].sz || del[i] == 2) continue; 
-        for (int j = 0; j < C[i].sz; j++) {
-            int v = C[i][j];
-            if (v > 0) pos[v]++;
-            else neg[-v]++;
-        }
-    }
-    for (int i = 1; i <= maxvar; i++) {
-        if (!C[i].sz || del[i] == 2) continue; 
-        if (C[i].type == Xor && pos[i] == 0 && neg[i] > 0) {
-            for (int j = 0; j < C[i].sz; j++)
-                if (C[i][j] < 0 && C[-C[i][j]].neg == 0) {C[i][j] = -C[i][j]; C[i].neg = 1; break;}
-        } 
-        // if (C[i].type == Xor) {
-        //     int z = 0;
-        //     for (int j = 0; j < C[i].sz; j++)
-        //         if (C[i][j] < 0) {C[i][j] = -C[i][j]; z ^= 1;}
-        //     if (z) C[i].neg = 1;
-        // }     
-    }
-}
-
-void Sweep::match_HA() {
-    std::map<int, int> M;
-    int lits = maxvar << 1 | 1;
-    for (int i = 1; i <= maxvar; i++) {
-        if (!C[i].sz || del[i] == 2 || C[i].type != And) continue; 
-        int mapid = C[i][0] * lits + C[i][1];
-        M[mapid] = i;
-    }
-    for (int i = 1; i <= maxvar; i++) {
-        if (!C[i].sz || del[i] == 2 || C[i].type != Xor) continue;  
-        int mapid = C[i][0] * lits + C[i][1];
-        int id = M[mapid];
-        if (id) {
-            C[i].type = HA;
-            C[i].carrier = id;
-            del[id] = 2;
-            continue;
-        }
-
-        mapid = (-C[i][0]) * lits - C[i][1];
-        id = M[mapid];
-        if (id) {
-            C[i].type = HA;
-            C[i].carrier = id;
-            C[i][0] = -C[i][0];
-            C[i][1] = -C[i][1];
-            del[id] = 2;
-            continue;
-        }
-
-        mapid = C[i][0] * lits - C[i][1];
-        id = M[mapid];
-        if (id) {
-            C[i].type = HA;
-            C[i].carrier = id;
-            C[i][1] = -C[i][1];
-            C[i].neg = 1;
-            del[id] = 2;
-            continue;
-        }
-
-        mapid = (-C[i][0]) * lits + C[i][1];
-        id = M[mapid];
-        if (id) {
-            C[i].type = HA;
-            C[i].carrier = id;
-            C[i][0] = -C[i][0];
-            C[i].neg = 1;
-            del[id] = 2;
-            continue;
-        }
-    }
-}
-
-bool Sweep::line_positive(int to) {
-    return (to < 0) == C[abs(to)].neg;
-}
-
-void Sweep::recalculate_outs() {
-    for (int i = 1; i <= maxvar; i++) 
-        C[i].outs = 0;
-    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++) {
-            C[abs(c->to[j])].outs++;
-        }
-    }
-}
-
-void Sweep::match_FA() {
-    for (int i = 1; i <= maxvar; i++) {
-        circuit *c = &C[i];
-        if (!c->sz || del[i] == 2) continue;
-        if (c->type != HA) continue;
-        C[abs(c->carrier)].to.clear();
-        C[abs(c->carrier)].to.push(i);
-        C[abs(c->carrier)].sz = 1;
-        C[abs(c->carrier)].neg = c->carrier < 0;
-    }
-
-    for(int i=1; i<=maxvar; i++) {
-        if (!C[i].sz || del[i] == 2) continue; 
-
-        circuit *c = &C[i];
-
-        if(c->type != And) continue;
-
-        if(c->sz != 2) continue;
-
-        if(c->to[0] >= 0) continue;
-        if(c->to[1] >= 0) continue;
-
-        if(C[abs(c->to[0])].sz != 1) continue;
-        if(C[abs(c->to[1])].sz != 1) continue;
-
-        int ha1 = C[abs(c->to[0])][0];
-        int ha2 = C[abs(c->to[1])][0];
-
-        ha1 = abs(ha1);
-        ha2 = abs(ha2);
-
-        if(C[ha1].type != HA) continue;
-        if(C[ha2].type != HA) continue;
-
-        bool check_link = true;
-        for(int k=0; k<C[ha1].sz; k++) {
-            int t = C[ha1].to[k];
-            if(abs(t) == ha2) std::swap(ha1, ha2);
-            if(abs(t) == ha2 && !line_positive(t))
-                check_link = false;
-        }
-        for(int k=0; k<C[ha2].sz; k++) {
-            int t = C[ha2].to[k];
-            if(abs(t) == ha1 && !line_positive(t))
-                check_link = false;
-        }
-
-        if(!check_link) continue;
-
-        //printf("FA %d(%d) %d(%d)\n", ha1, C[ha1].neg, ha2, C[ha2].neg);
-
-        if(C[ha1].outs == 2) del[ha1] = 2;
-
-        circuit* fa = &C[ha2];
-        fa->type = FA;
-        fa->carrier = -i;
-        vec<int> new_vec;
-        for(int k=0; k<C[ha1].sz; k++) {
-            int t = C[ha1].to[k];
-            if(abs(t) == ha2) continue;
-            new_vec.push(t);
-            //printf("push: %d\n", t);
-        }
-        for(int k=0; k<C[ha2].sz; k++) {
-            int t = C[ha2].to[k];
-            if(abs(t) == ha1) continue;
-            //printf("push: %d\n", k, t);
-            new_vec.push(t);
-        }
-        new_vec.copyTo(fa->to);
-        fa->sz = fa->to.size();
-
-        C[i].to.clear();
-        C[i].sz = 0;
-        C[i].neg = !C[i].neg;
-    }
-}
-
-void Sweep::to_multi_input_gates() {
-    //printf("hello\n %d\n", maxvar);
-    std::queue<int> q;
-    q.push(maxvar);
-    while(!q.empty()) {
-        int u = q.front();
-        q.pop();
-
-        circuit *c = &C[u];
-
-        if(u == maxvar) {
-            for(int i=0; i<c->sz; i++) {
-                if (!C[abs(c->to[i])].sz || del[abs(c->to[i])] == 2) continue;
-                q.push(abs(c->to[i]));
-            }
-            continue;
-        }
-        
-        for(int i=0; i<c->sz; i++) {
-            circuit *t = &C[abs(c->to[i])];
-            if(t->type != c->type) continue;
-            vec<int> new_vec;
-            if(c->type == Xor) {
-                //printf("XOR: %d %d\n", u, c->to[i]);
-                for(int j=0; j<t->sz; j++) {
-                    new_vec.push(t->to[j]);
-                    //printf("add %d\n", t->to[j]);
-                }
-                
-                for(int j=0; j<c->sz; j++) {
-                    if(i == j) {
-                        if(!line_positive(c->to[j]))
-                            new_vec[0] = -new_vec[0];
-                    } else {
-                        new_vec.push(c->to[j]);
-                    }
-                }
-
-                if(t->outs == 1) {
-                    del[abs(c->to[i])] = 2;
-                    //printf("del: %d\n", c->to[i]);
-                }
-
-                new_vec.copyTo(c->to);
-                c->sz = new_vec.size();
-
-                q.push(u);
-                break;
-            }
-
-            if(c->type == And && line_positive(c->to[i])) {
-                if(t->to.size() == 0) continue;
-
-                //printf("AND: %d %d\n", u, c->to[i]);
-                t->to.copyTo(new_vec);
-                //printf("new_vec %d\n", new_vec.size());
-
-                for(int j=0; j<c->sz; j++) {
-                    if(i != j) {
-                        new_vec.push(c->to[j]);
-                    }
-                }
-
-                if(C[abs(c->to[i])].outs == 1)  {
-                    del[abs(c->to[i])] = 2;
-                }
-
-                new_vec.copyTo(c->to);
-                c->sz = new_vec.size();
-
-                q.push(u);
-
-                break;
-            }
-        }
-
-        
-
-        for(int i=0; i<c->sz; i++) {
-            if (!C[abs(c->to[i])].sz || del[abs(c->to[i])] == 2) continue;
-            q.push(abs(c->to[i]));
-        }
-    }
-}
-
-void Sweep::to_dot_graph(const char* filename, int end_point) {
-    std::ofstream file(filename);
-    std::queue<int> q;
-    q.push(abs(end_point));
-    std::set<int> used;
-    used.insert(abs(end_point));
-    file << "digraph \"graph\" {\n";
-
-    char str[1024];
-
-    while(!q.empty()) {
-        int u = q.front();
-        q.pop();
-        circuit *c = &C[u];
-
-        if(!c->sz || del[u] == 2) continue;
-
-        sprintf(str, "A%d[label=\"%d (%s)\"];\n", u, u, gate_type[c->type].c_str());
-        file << str;
-        if (c->type == HA || c->type == FA) {
-            int a = u * (C[u].neg ? -1 : 1);
-            int b = c->carrier;
-            sprintf(str, "A%d->A%d[arrowhead=%s]\n", u, abs(b), !line_positive(b) ? "dot" : "none");
-            file << str;
-        }
-        else {
-            int t = u * (C[u].neg ? -1 : 1);
-        }
-        for (int j = 0; j < c->sz; j++) {
-            /**
-             * 删除初始输入
-            */
-            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;
-        }
-
-        for(int j=0; j<c->sz; j++) {
-            int x = abs(c->to[j]);
-            if(used.count(x)) continue;
-            used.insert(x);
-            q.push(x);
-        }
-    }
-    
-    file << "}\n";
-}
-
-void Sweep::identify() {
-    
-    del = new int[maxvar + 1];
-    for (int i = 1; i <= maxvar; i++) del[i] = 0;
-    recalculate_outs();
-    for (int i = 1; i <= maxvar; i++) {
-        if (!C[i].sz || del[i] == 2) continue;
-        if (match_xor(i)) continue;
-    }
-    
-    // recalculate_outs();
-
-    // 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();
-
-    //to_multi_input_gates();
-    //match_FA();
-
-    // printf("digraph \"graph\" {\n");
-    // for (int i = 1; i <= maxvar; i++) {
-    //     circuit *c = &C[i];
-    //     if (!c->sz || del[i] == 2) continue;
-
-    //     printf("A%d[label=\"%d (%s)\"];\n", i, i, gate_type[c->type].c_str());
-
-    //     if (c->type == HA || c->type == FA) {
-    //         int a = i * (C[i].neg ? -1 : 1);
-    //         int b = c->carrier;
-    //         printf("A%d->A%d[arrowhead=%s]\n", i, abs(b), !line_positive(b) ? "dot" : "none");
-    //     }
-    //     else {
-    //         int t = i * (C[i].neg ? -1 : 1);
-    //     }
-    //     for (int j = 0; j < c->sz; j++) {
-    //         if(abs(c->to[j]) <= 14) continue;
-    //         printf("A%d->A%d[arrowhead=%s]\n", abs(c->to[j]), i, !line_positive(c->to[j]) ? "dot" : "none");
-    //     }
-    // }
-    // printf("}\n");
-
-    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++) {
-    //     circuit *c = &C[i];
-    //     if (del[i] == 2) continue; 
-    //     printf("%d : %d (outs)\n", i, c->outs);
-    // }
-    
-}
\ No newline at end of file
diff --git a/circuit.hpp b/circuit.hpp
deleted file mode 100644
index 384e563..0000000
--- a/circuit.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef circuit_hpp_INCLUDED
-#define circuit_hpp_INCLUDED
-
-enum gate_type {And, Xor, Majority, HA, FA};
-const std::string gate_type[5] = {"and", "xor", "majority", "HA", "FA"};
-
-struct circuit {
-    vec<int> to;
-    int sz, outs, type, neg, carrier;
-    circuit() : sz(0), outs(0), type(0), neg(0), carrier(0) {}
-    void push(int x) { to.push(x); sz++; }
-    int &operator [] (int index)  { return to[index]; }
-    const int& operator [] (int index) const { return to[index]; }
-};
-
-#endif
\ No newline at end of file
diff --git a/cms.log b/cms.log
deleted file mode 100644
index 8ae66aa..0000000
--- a/cms.log
+++ /dev/null
@@ -1,408 +0,0 @@
--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/fraig.cpp b/fraig.cpp
deleted file mode 100644
index 1e8089f..0000000
--- a/fraig.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-#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
deleted file mode 100644
index 8804f3f..0000000
--- a/hCaD_V2/BUILD.md
+++ /dev/null
@@ -1,104 +0,0 @@
-# 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
deleted file mode 100644
index fbf1cdd..0000000
--- a/hCaD_V2/CONTRIBUTING
+++ /dev/null
@@ -1,4 +0,0 @@
-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
deleted file mode 100644
index 81065ff..0000000
--- a/hCaD_V2/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-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
deleted file mode 100644
index 756f3b8..0000000
--- a/hCaD_V2/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-[![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
deleted file mode 100644
index 347f583..0000000
--- a/hCaD_V2/VERSION
+++ /dev/null
@@ -1 +0,0 @@
-1.4.1
diff --git a/hCaD_V2/bin/starexec_run_default b/hCaD_V2/bin/starexec_run_default
deleted file mode 100644
index d24f815..0000000
--- a/hCaD_V2/bin/starexec_run_default
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/sh
-exec ./cadical --target=0 --walk=false $1 $2/proof.out
diff --git a/hCaD_V2/configure b/hCaD_V2/configure
deleted file mode 100755
index e761d26..0000000
--- a/hCaD_V2/configure
+++ /dev/null
@@ -1,494 +0,0 @@
-#!/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
deleted file mode 100644
index afb0bfc..0000000
--- a/hCaD_V2/makefile
+++ /dev/null
@@ -1,24 +0,0 @@
-CADICALBUILD=/home/qianyh/experiments/cec/ACEC/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/qianyh/experiments/cec/ACEC/hCaD_V2/src/makefile"
-	rm -f "/home/qianyh/experiments/cec/ACEC/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
deleted file mode 100644
index 69b4d22..0000000
--- a/hCaD_V2/makefile.in
+++ /dev/null
@@ -1,84 +0,0 @@
-#==========================================================================#
-# 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
deleted file mode 100644
index bc7bb5a..0000000
--- a/hCaD_V2/scripts/README.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# 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
deleted file mode 100755
index fafc880..0000000
--- a/hCaD_V2/scripts/build-and-test-all-configurations.sh
+++ /dev/null
@@ -1,115 +0,0 @@
-#!/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
deleted file mode 100755
index e83ef4e..0000000
--- a/hCaD_V2/scripts/check-options-occur.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/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
deleted file mode 100755
index d65b919..0000000
--- a/hCaD_V2/scripts/colors.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-# 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
deleted file mode 100755
index 44d8e8e..0000000
--- a/hCaD_V2/scripts/extend-solution.sh
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/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
deleted file mode 100755
index 7b936ac..0000000
--- a/hCaD_V2/scripts/generate-cubes.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/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
deleted file mode 100755
index 15b44d1..0000000
--- a/hCaD_V2/scripts/generate-embedded-options-default-list.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/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
deleted file mode 100755
index f5727ca..0000000
--- a/hCaD_V2/scripts/generate-options-range-list.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/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
deleted file mode 100755
index 69b1d1f..0000000
--- a/hCaD_V2/scripts/get-git-id.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/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
deleted file mode 100755
index e8f6746..0000000
--- a/hCaD_V2/scripts/make-build-header.sh
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/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
deleted file mode 100755
index 1b546e4..0000000
--- a/hCaD_V2/scripts/make-src-release.sh
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/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
deleted file mode 100755
index eb513c3..0000000
--- a/hCaD_V2/scripts/normalize-white-space.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/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
deleted file mode 100755
index 143f5ef..0000000
--- a/hCaD_V2/scripts/prepare-sc2021-submission.sh
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/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
deleted file mode 100755
index 6ddd6d1..0000000
--- a/hCaD_V2/scripts/run-cadical-and-check-proof.sh
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/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
deleted file mode 100755
index 945f22f..0000000
--- a/hCaD_V2/scripts/run-simplifier-and-extend-solution.sh
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/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
deleted file mode 100755
index b447b52..0000000
--- a/hCaD_V2/scripts/update-example-in-cadical-header-file.sh
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/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
deleted file mode 100755
index 58641ac..0000000
--- a/hCaD_V2/scripts/update-version.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/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
deleted file mode 100644
index f17395f..0000000
--- a/hCaD_V2/src/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index 5f3f643..0000000
--- a/hCaD_V2/src/analyze.cpp
+++ /dev/null
@@ -1,830 +0,0 @@
-#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
deleted file mode 100644
index 61123ec..0000000
--- a/hCaD_V2/src/arena.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#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
deleted file mode 100644
index 1a41ade..0000000
--- a/hCaD_V2/src/arena.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#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
deleted file mode 100644
index c79cfa8..0000000
--- a/hCaD_V2/src/assume.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-#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
deleted file mode 100644
index 9376e6e..0000000
--- a/hCaD_V2/src/averages.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#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
deleted file mode 100644
index 1d4451c..0000000
--- a/hCaD_V2/src/averages.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#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
deleted file mode 100644
index a9a7f62..0000000
--- a/hCaD_V2/src/backtrack.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#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
deleted file mode 100644
index 851de45..0000000
--- a/hCaD_V2/src/backward.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#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
deleted file mode 100644
index 8f108a3..0000000
--- a/hCaD_V2/src/bins.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#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
deleted file mode 100644
index e55f0f5..0000000
--- a/hCaD_V2/src/bins.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#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
deleted file mode 100644
index 185053d..0000000
--- a/hCaD_V2/src/block.cpp
+++ /dev/null
@@ -1,751 +0,0 @@
-#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
deleted file mode 100644
index 04ce12e..0000000
--- a/hCaD_V2/src/block.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#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
deleted file mode 100644
index 37293e6..0000000
--- a/hCaD_V2/src/cadical.cpp
+++ /dev/null
@@ -1,933 +0,0 @@
-/*------------------------------------------------------------------------*/
-
-// 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
deleted file mode 100644
index cbb064b..0000000
--- a/hCaD_V2/src/cadical.hpp
+++ /dev/null
@@ -1,891 +0,0 @@
-#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
deleted file mode 100644
index 2141c56..0000000
--- a/hCaD_V2/src/ccadical.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-#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
deleted file mode 100644
index 4173aed..0000000
--- a/hCaD_V2/src/ccadical.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#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
deleted file mode 100644
index 1257f47..0000000
--- a/hCaD_V2/src/checker.cpp
+++ /dev/null
@@ -1,555 +0,0 @@
-#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
deleted file mode 100644
index 90bfa7e..0000000
--- a/hCaD_V2/src/checker.hpp
+++ /dev/null
@@ -1,165 +0,0 @@
-#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
deleted file mode 100644
index 5f3b701..0000000
--- a/hCaD_V2/src/clause.cpp
+++ /dev/null
@@ -1,442 +0,0 @@
-#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
deleted file mode 100644
index f92e57b..0000000
--- a/hCaD_V2/src/clause.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-#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
deleted file mode 100644
index 4e0a4a2..0000000
--- a/hCaD_V2/src/collect.cpp
+++ /dev/null
@@ -1,429 +0,0 @@
-#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
deleted file mode 100644
index 4a2cc05..0000000
--- a/hCaD_V2/src/compact.cpp
+++ /dev/null
@@ -1,416 +0,0 @@
-#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
deleted file mode 100644
index 6d7b91a..0000000
--- a/hCaD_V2/src/condition.cpp
+++ /dev/null
@@ -1,898 +0,0 @@
-#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
deleted file mode 100644
index 1ca5440..0000000
--- a/hCaD_V2/src/config.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#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
deleted file mode 100644
index c66a10f..0000000
--- a/hCaD_V2/src/config.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#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
deleted file mode 100644
index e761d26..0000000
--- a/hCaD_V2/src/configure
+++ /dev/null
@@ -1,494 +0,0 @@
-#!/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
deleted file mode 100644
index 015abfa..0000000
--- a/hCaD_V2/src/contract.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#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
deleted file mode 100644
index ec5a6ba..0000000
--- a/hCaD_V2/src/contract.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#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
deleted file mode 100644
index 292a94c..0000000
--- a/hCaD_V2/src/cover.cpp
+++ /dev/null
@@ -1,588 +0,0 @@
-#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
deleted file mode 100644
index 0735758..0000000
--- a/hCaD_V2/src/cover.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#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
deleted file mode 100644
index 8f5249e..0000000
--- a/hCaD_V2/src/decide.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#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
deleted file mode 100644
index e6bcd7f..0000000
--- a/hCaD_V2/src/decompose.cpp
+++ /dev/null
@@ -1,361 +0,0 @@
-#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
deleted file mode 100644
index f7e018d..0000000
--- a/hCaD_V2/src/deduplicate.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#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
deleted file mode 100644
index dbb358b..0000000
--- a/hCaD_V2/src/elim.cpp
+++ /dev/null
@@ -1,960 +0,0 @@
-#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
deleted file mode 100644
index a362a1a..0000000
--- a/hCaD_V2/src/elim.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#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
deleted file mode 100644
index c61efbd..0000000
--- a/hCaD_V2/src/ema.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#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
deleted file mode 100644
index 3a6f8cd..0000000
--- a/hCaD_V2/src/ema.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#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
deleted file mode 100644
index d84ba95..0000000
--- a/hCaD_V2/src/extend.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-#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
deleted file mode 100644
index 73725d7..0000000
--- a/hCaD_V2/src/external.cpp
+++ /dev/null
@@ -1,541 +0,0 @@
-#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
deleted file mode 100644
index a7fb452..0000000
--- a/hCaD_V2/src/external.hpp
+++ /dev/null
@@ -1,356 +0,0 @@
-#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
deleted file mode 100644
index 01b2ec5..0000000
--- a/hCaD_V2/src/file.cpp
+++ /dev/null
@@ -1,306 +0,0 @@
-#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
deleted file mode 100644
index 8fef7f1..0000000
--- a/hCaD_V2/src/file.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#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
deleted file mode 100644
index cd6cb3d..0000000
--- a/hCaD_V2/src/flags.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#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
deleted file mode 100644
index 3c86892..0000000
--- a/hCaD_V2/src/flags.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#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
deleted file mode 100644
index 2efdc2e..0000000
--- a/hCaD_V2/src/format.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#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
deleted file mode 100644
index d0444e5..0000000
--- a/hCaD_V2/src/format.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#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
deleted file mode 100644
index ae63463..0000000
--- a/hCaD_V2/src/gates.cpp
+++ /dev/null
@@ -1,527 +0,0 @@
-#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
deleted file mode 100644
index 5e470af..0000000
--- a/hCaD_V2/src/heap.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-#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
deleted file mode 100644
index 9f3785a..0000000
--- a/hCaD_V2/src/instantiate.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-#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
deleted file mode 100644
index 60ed660..0000000
--- a/hCaD_V2/src/instantiate.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#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
deleted file mode 100644
index b1e71cf..0000000
--- a/hCaD_V2/src/internal.cpp
+++ /dev/null
@@ -1,739 +0,0 @@
-#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
deleted file mode 100644
index 8d8ebbc..0000000
--- a/hCaD_V2/src/internal.hpp
+++ /dev/null
@@ -1,1351 +0,0 @@
-#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
deleted file mode 100644
index 90f8093..0000000
--- a/hCaD_V2/src/ipasir.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#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
deleted file mode 100644
index f54ee58..0000000
--- a/hCaD_V2/src/ipasir.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#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
deleted file mode 100644
index f583ad8..0000000
--- a/hCaD_V2/src/level.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#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
deleted file mode 100644
index 86e74b7..0000000
--- a/hCaD_V2/src/limit.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-#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
deleted file mode 100644
index 66eef0b..0000000
--- a/hCaD_V2/src/limit.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#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
deleted file mode 100644
index 59d3df3..0000000
--- a/hCaD_V2/src/logging.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#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
deleted file mode 100644
index 1012493..0000000
--- a/hCaD_V2/src/logging.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#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
deleted file mode 100644
index 9e8a16b..0000000
--- a/hCaD_V2/src/lookahead.cpp
+++ /dev/null
@@ -1,504 +0,0 @@
-#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
deleted file mode 100644
index 25f34cd..0000000
--- a/hCaD_V2/src/lucky.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-#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
deleted file mode 120000
index e3356b1..0000000
--- a/hCaD_V2/src/makefile
+++ /dev/null
@@ -1 +0,0 @@
-/home/qianyh/experiments/cec/ACEC/hCaD_V2/makefile
\ No newline at end of file
diff --git a/hCaD_V2/src/message.cpp b/hCaD_V2/src/message.cpp
deleted file mode 100644
index 651d098..0000000
--- a/hCaD_V2/src/message.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-#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
deleted file mode 100644
index 162187f..0000000
--- a/hCaD_V2/src/message.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#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
deleted file mode 100644
index 2495129..0000000
--- a/hCaD_V2/src/minimize.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#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
deleted file mode 100644
index 9b373b1..0000000
--- a/hCaD_V2/src/mobical.cpp
+++ /dev/null
@@ -1,3082 +0,0 @@
-/*------------------------------------------------------------------------*/
-/* 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
deleted file mode 100644
index 70d0997..0000000
--- a/hCaD_V2/src/observer.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#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
deleted file mode 100644
index d796589..0000000
--- a/hCaD_V2/src/occs.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#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
deleted file mode 100644
index 5aa3873..0000000
--- a/hCaD_V2/src/occs.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#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
deleted file mode 100644
index 519f56a..0000000
--- a/hCaD_V2/src/options.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-#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
deleted file mode 100644
index 3cc1251..0000000
--- a/hCaD_V2/src/options.hpp
+++ /dev/null
@@ -1,347 +0,0 @@
-#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
deleted file mode 100644
index 21bb620..0000000
--- a/hCaD_V2/src/parse.cpp
+++ /dev/null
@@ -1,368 +0,0 @@
-#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
deleted file mode 100644
index a8a98ab..0000000
--- a/hCaD_V2/src/parse.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#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
deleted file mode 100644
index dc768db..0000000
--- a/hCaD_V2/src/phases.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#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
deleted file mode 100644
index 4f7dc90..0000000
--- a/hCaD_V2/src/phases.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#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
deleted file mode 100644
index f85f5f1..0000000
--- a/hCaD_V2/src/probe.cpp
+++ /dev/null
@@ -1,687 +0,0 @@
-#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
deleted file mode 100644
index afd202a..0000000
--- a/hCaD_V2/src/profile.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#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
deleted file mode 100644
index 9ec3ed4..0000000
--- a/hCaD_V2/src/profile.hpp
+++ /dev/null
@@ -1,258 +0,0 @@
-#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
deleted file mode 100644
index 9e8c060..0000000
--- a/hCaD_V2/src/proof.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-#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
deleted file mode 100644
index 05ae609..0000000
--- a/hCaD_V2/src/proof.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#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
deleted file mode 100644
index 45e38e9..0000000
--- a/hCaD_V2/src/propagate.cpp
+++ /dev/null
@@ -1,382 +0,0 @@
-#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
deleted file mode 100644
index ff167c8..0000000
--- a/hCaD_V2/src/queue.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#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
deleted file mode 100644
index 94e0dcc..0000000
--- a/hCaD_V2/src/queue.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#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
deleted file mode 100644
index bd28f56..0000000
--- a/hCaD_V2/src/radix.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#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
deleted file mode 100644
index a85703d..0000000
--- a/hCaD_V2/src/random.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-#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
deleted file mode 100644
index 290dbf4..0000000
--- a/hCaD_V2/src/random.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-/*------------------------------------------------------------------------*/
-
-// 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
deleted file mode 100644
index 9c1fc2a..0000000
--- a/hCaD_V2/src/range.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#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
deleted file mode 100644
index 93a26b8..0000000
--- a/hCaD_V2/src/reap.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-#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
deleted file mode 100644
index 3ad4875..0000000
--- a/hCaD_V2/src/reap.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#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
deleted file mode 100644
index c7efffe..0000000
--- a/hCaD_V2/src/reduce.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-#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
deleted file mode 100644
index fb62d67..0000000
--- a/hCaD_V2/src/reluctant.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#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
deleted file mode 100644
index 6951144..0000000
--- a/hCaD_V2/src/rephase.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-#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
deleted file mode 100644
index 31e23ea..0000000
--- a/hCaD_V2/src/report.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#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
deleted file mode 100644
index f4f72cc..0000000
--- a/hCaD_V2/src/resources.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#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
deleted file mode 100644
index 7ecc6e8..0000000
--- a/hCaD_V2/src/resources.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#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
deleted file mode 100644
index 20df6d2..0000000
--- a/hCaD_V2/src/restart.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#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
deleted file mode 100644
index 39f07a7..0000000
--- a/hCaD_V2/src/restore.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-#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
deleted file mode 100644
index a9eea6a..0000000
--- a/hCaD_V2/src/score.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#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
deleted file mode 100644
index 1911186..0000000
--- a/hCaD_V2/src/score.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#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
deleted file mode 100644
index 3b5228a..0000000
--- a/hCaD_V2/src/shrink.cpp
+++ /dev/null
@@ -1,446 +0,0 @@
-#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
deleted file mode 100644
index f134aa7..0000000
--- a/hCaD_V2/src/signal.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#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
deleted file mode 100644
index 9e29494..0000000
--- a/hCaD_V2/src/signal.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#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
deleted file mode 100644
index 4041b65..0000000
--- a/hCaD_V2/src/solution.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#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
deleted file mode 100644
index 13c8d72..0000000
--- a/hCaD_V2/src/solver.cpp
+++ /dev/null
@@ -1,1273 +0,0 @@
-#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
deleted file mode 100644
index ac38240..0000000
--- a/hCaD_V2/src/stats.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-// 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
deleted file mode 100644
index 753c458..0000000
--- a/hCaD_V2/src/stats.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-#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
deleted file mode 100644
index f1aadaa..0000000
--- a/hCaD_V2/src/subsume.cpp
+++ /dev/null
@@ -1,612 +0,0 @@
-#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
deleted file mode 100644
index 86703e4..0000000
--- a/hCaD_V2/src/terminal.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#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
deleted file mode 100644
index 62c3755..0000000
--- a/hCaD_V2/src/terminal.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#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
deleted file mode 100644
index fdca428..0000000
--- a/hCaD_V2/src/ternary.cpp
+++ /dev/null
@@ -1,365 +0,0 @@
-#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
deleted file mode 100644
index 2db8cde..0000000
--- a/hCaD_V2/src/tracer.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#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
deleted file mode 100644
index cc8f303..0000000
--- a/hCaD_V2/src/tracer.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#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
deleted file mode 100644
index 14e7081..0000000
--- a/hCaD_V2/src/transred.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-#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
deleted file mode 100644
index d012fcd..0000000
--- a/hCaD_V2/src/util.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#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
deleted file mode 100644
index 7a94f23..0000000
--- a/hCaD_V2/src/util.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#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
deleted file mode 100644
index cc27258..0000000
--- a/hCaD_V2/src/var.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#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
deleted file mode 100644
index 2a666e5..0000000
--- a/hCaD_V2/src/var.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#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
deleted file mode 100644
index 1b81af0..0000000
--- a/hCaD_V2/src/version.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*------------------------------------------------------------------------*/
-
-// 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
deleted file mode 100644
index ce48573..0000000
--- a/hCaD_V2/src/version.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 324f43a..0000000
--- a/hCaD_V2/src/vivify.cpp
+++ /dev/null
@@ -1,1097 +0,0 @@
-#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
deleted file mode 100644
index 05b2538..0000000
--- a/hCaD_V2/src/vivify.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#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
deleted file mode 100644
index bbda837..0000000
--- a/hCaD_V2/src/walk.cpp
+++ /dev/null
@@ -1,667 +0,0 @@
-#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
deleted file mode 100644
index 158b9da..0000000
--- a/hCaD_V2/src/watch.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#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
deleted file mode 100644
index 0b8a1d8..0000000
--- a/hCaD_V2/src/watch.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#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
deleted file mode 100644
index 2c1f8fe..0000000
--- a/hCaD_V2/starexec_build
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/sh
-
-./configure --competition
-make
-cp build/cadical ./bin/
diff --git a/hCaD_V2/starexec_description.txt b/hCaD_V2/starexec_description.txt
deleted file mode 100644
index 5130943..0000000
--- a/hCaD_V2/starexec_description.txt
+++ /dev/null
@@ -1 +0,0 @@
-hCaD V2 is submitted to the CaDiCaL Hack Track
diff --git a/hCaD_V2/test/README.md b/hCaD_V2/test/README.md
deleted file mode 100644
index 0d488c0..0000000
--- a/hCaD_V2/test/README.md
+++ /dev/null
@@ -1,55 +0,0 @@
-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
deleted file mode 100644
index ea38b92..0000000
--- a/hCaD_V2/test/api/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index c8b4ba5..0000000
--- a/hCaD_V2/test/api/apitrace.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#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
deleted file mode 100644
index 0747596..0000000
--- a/hCaD_V2/test/api/cfreeze.c
+++ /dev/null
@@ -1,94 +0,0 @@
-// 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
deleted file mode 100644
index 9972731..0000000
--- a/hCaD_V2/test/api/cipasir.c
+++ /dev/null
@@ -1,114 +0,0 @@
-#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
deleted file mode 100644
index 714e032..0000000
--- a/hCaD_V2/test/api/ctest.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#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
deleted file mode 100644
index 456e76e..0000000
--- a/hCaD_V2/test/api/example.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#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
deleted file mode 100644
index f856d6d..0000000
--- a/hCaD_V2/test/api/learn.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#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
deleted file mode 100644
index 9c4f4de..0000000
--- a/hCaD_V2/test/api/makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-# 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
deleted file mode 100644
index 16f56ae..0000000
--- a/hCaD_V2/test/api/morenmore.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#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
deleted file mode 100644
index e9adadb..0000000
--- a/hCaD_V2/test/api/newdelete.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#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
deleted file mode 100644
index 5ee10e9..0000000
--- a/hCaD_V2/test/api/run.sh
+++ /dev/null
@@ -1,123 +0,0 @@
-#!/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
deleted file mode 100644
index 0dd5bde..0000000
--- a/hCaD_V2/test/api/terminate.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#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
deleted file mode 100644
index c4ca00d..0000000
--- a/hCaD_V2/test/api/traverse.cpp
+++ /dev/null
@@ -1,144 +0,0 @@
-#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
deleted file mode 100644
index e8196e1..0000000
--- a/hCaD_V2/test/api/unit.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#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
deleted file mode 100644
index 5b9dfe3..0000000
--- a/hCaD_V2/test/cnf/README.md
+++ /dev/null
@@ -1,23 +0,0 @@
-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
deleted file mode 100644
index 2c34c84..0000000
--- a/hCaD_V2/test/cnf/drat-trim.c
+++ /dev/null
@@ -1,1610 +0,0 @@
-/************************************************************************************[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
deleted file mode 100644
index f9eab33..0000000
--- a/hCaD_V2/test/cnf/empty.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 0
diff --git a/hCaD_V2/test/cnf/makefile b/hCaD_V2/test/cnf/makefile
deleted file mode 100644
index 370c9eb..0000000
--- a/hCaD_V2/test/cnf/makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-# 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
deleted file mode 100644
index b48b4fe..0000000
--- a/hCaD_V2/test/cnf/precochk.c
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- * 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
deleted file mode 100644
index f5ca8fe..0000000
--- a/hCaD_V2/test/cnf/prime121.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index f44cbdf..0000000
--- a/hCaD_V2/test/cnf/prime1369.sol
+++ /dev/null
@@ -1,61 +0,0 @@
-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
deleted file mode 100644
index 5b3637c..0000000
--- a/hCaD_V2/test/cnf/prime1681.sol
+++ /dev/null
@@ -1,61 +0,0 @@
-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
deleted file mode 100644
index 747ef81..0000000
--- a/hCaD_V2/test/cnf/prime169.sol
+++ /dev/null
@@ -1,28 +0,0 @@
-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
deleted file mode 100644
index 2e695fd..0000000
--- a/hCaD_V2/test/cnf/prime1849.sol
+++ /dev/null
@@ -1,61 +0,0 @@
-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
deleted file mode 100644
index 3ceb5b4..0000000
--- a/hCaD_V2/test/cnf/prime2209.sol
+++ /dev/null
@@ -1,77 +0,0 @@
-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
deleted file mode 100644
index f9fb287..0000000
--- a/hCaD_V2/test/cnf/prime25.sol
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index abe3fba..0000000
--- a/hCaD_V2/test/cnf/prime289.sol
+++ /dev/null
@@ -1,38 +0,0 @@
-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
deleted file mode 100644
index 10bf663..0000000
--- a/hCaD_V2/test/cnf/prime361.sol
+++ /dev/null
@@ -1,38 +0,0 @@
-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
deleted file mode 100644
index 2a7a8d5..0000000
--- a/hCaD_V2/test/cnf/prime4.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-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
deleted file mode 100644
index 24f0853..0000000
--- a/hCaD_V2/test/cnf/prime49.sol
+++ /dev/null
@@ -1,13 +0,0 @@
-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
deleted file mode 100644
index f1e8f7c..0000000
--- a/hCaD_V2/test/cnf/prime529.sol
+++ /dev/null
@@ -1,49 +0,0 @@
-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
deleted file mode 100644
index 9cfa7cf..0000000
--- a/hCaD_V2/test/cnf/prime841.sol
+++ /dev/null
@@ -1,49 +0,0 @@
-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
deleted file mode 100644
index 7ad9eb1..0000000
--- a/hCaD_V2/test/cnf/prime9.sol
+++ /dev/null
@@ -1,4 +0,0 @@
-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
deleted file mode 100644
index c5ace62..0000000
--- a/hCaD_V2/test/cnf/prime961.sol
+++ /dev/null
@@ -1,48 +0,0 @@
-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
deleted file mode 100644
index a793b84..0000000
--- a/hCaD_V2/test/cnf/regr000.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-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
deleted file mode 100644
index f69e617..0000000
--- a/hCaD_V2/test/cnf/run.sh
+++ /dev/null
@@ -1,314 +0,0 @@
-#!/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
deleted file mode 100644
index 4904b64..0000000
--- a/hCaD_V2/test/cnf/sat1.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 2 0
diff --git a/hCaD_V2/test/cnf/sat10.sol b/hCaD_V2/test/cnf/sat10.sol
deleted file mode 100644
index cf21d8c..0000000
--- a/hCaD_V2/test/cnf/sat10.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 2 3 0
diff --git a/hCaD_V2/test/cnf/sat11.sol b/hCaD_V2/test/cnf/sat11.sol
deleted file mode 100644
index 0e6dc62..0000000
--- a/hCaD_V2/test/cnf/sat11.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 2 -3 0
diff --git a/hCaD_V2/test/cnf/sat12.sol b/hCaD_V2/test/cnf/sat12.sol
deleted file mode 100644
index 280ec06..0000000
--- a/hCaD_V2/test/cnf/sat12.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 -2 3 0
diff --git a/hCaD_V2/test/cnf/sat13.sol b/hCaD_V2/test/cnf/sat13.sol
deleted file mode 100644
index dab4908..0000000
--- a/hCaD_V2/test/cnf/sat13.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 -2 -3 0
diff --git a/hCaD_V2/test/cnf/sat2.sol b/hCaD_V2/test/cnf/sat2.sol
deleted file mode 100644
index 9aa456a..0000000
--- a/hCaD_V2/test/cnf/sat2.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 -2 0
diff --git a/hCaD_V2/test/cnf/sat3.sol b/hCaD_V2/test/cnf/sat3.sol
deleted file mode 100644
index 543c85e..0000000
--- a/hCaD_V2/test/cnf/sat3.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 2 0
diff --git a/hCaD_V2/test/cnf/sat4.sol b/hCaD_V2/test/cnf/sat4.sol
deleted file mode 100644
index 8aafa17..0000000
--- a/hCaD_V2/test/cnf/sat4.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 -2 0
diff --git a/hCaD_V2/test/cnf/sat6.sol b/hCaD_V2/test/cnf/sat6.sol
deleted file mode 100644
index 272b0bc..0000000
--- a/hCaD_V2/test/cnf/sat6.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 2 3 0
diff --git a/hCaD_V2/test/cnf/sat7.sol b/hCaD_V2/test/cnf/sat7.sol
deleted file mode 100644
index c542e1d..0000000
--- a/hCaD_V2/test/cnf/sat7.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 2 -3 0
diff --git a/hCaD_V2/test/cnf/sat8.sol b/hCaD_V2/test/cnf/sat8.sol
deleted file mode 100644
index 65863b6..0000000
--- a/hCaD_V2/test/cnf/sat8.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 -2 3 0
diff --git a/hCaD_V2/test/cnf/sat9.sol b/hCaD_V2/test/cnf/sat9.sol
deleted file mode 100644
index c94ff9a..0000000
--- a/hCaD_V2/test/cnf/sat9.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 -2 -3 0
diff --git a/hCaD_V2/test/cnf/sqrt10201.sol b/hCaD_V2/test/cnf/sqrt10201.sol
deleted file mode 100644
index 5386d08..0000000
--- a/hCaD_V2/test/cnf/sqrt10201.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index ce082fc..0000000
--- a/hCaD_V2/test/cnf/sqrt1042441.sol
+++ /dev/null
@@ -1,42 +0,0 @@
-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
deleted file mode 100644
index 73d5757..0000000
--- a/hCaD_V2/test/cnf/sqrt10609.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index d8c7c7e..0000000
--- a/hCaD_V2/test/cnf/sqrt11449.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 804b0f7..0000000
--- a/hCaD_V2/test/cnf/sqrt11881.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 233f78c..0000000
--- a/hCaD_V2/test/cnf/sqrt12769.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index edf19dc..0000000
--- a/hCaD_V2/test/cnf/sqrt16129.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 9a5b008..0000000
--- a/hCaD_V2/test/cnf/sqrt259081.sol
+++ /dev/null
@@ -1,33 +0,0 @@
-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
deleted file mode 100644
index 2fbbe3d..0000000
--- a/hCaD_V2/test/cnf/sqrt2809.sol
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 5a8e321..0000000
--- a/hCaD_V2/test/cnf/sqrt3481.sol
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 21b4adf..0000000
--- a/hCaD_V2/test/cnf/sqrt3721.sol
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 7da087b..0000000
--- a/hCaD_V2/test/cnf/sqrt4489.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index b704991..0000000
--- a/hCaD_V2/test/cnf/sqrt5041.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 77abcf7..0000000
--- a/hCaD_V2/test/cnf/sqrt5329.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 8bb2c7c..0000000
--- a/hCaD_V2/test/cnf/sqrt6241.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 3983987..0000000
--- a/hCaD_V2/test/cnf/sqrt63001.sol
+++ /dev/null
@@ -1,26 +0,0 @@
-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
deleted file mode 100644
index 2544373..0000000
--- a/hCaD_V2/test/cnf/sqrt6889.sol
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 3acceaa..0000000
--- a/hCaD_V2/test/cnf/sqrt7921.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 4250adb..0000000
--- a/hCaD_V2/test/cnf/sqrt9409.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 697c38f..0000000
--- a/hCaD_V2/test/cnf/unit0.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 0
diff --git a/hCaD_V2/test/cnf/unit1.sol b/hCaD_V2/test/cnf/unit1.sol
deleted file mode 100644
index ca75ebf..0000000
--- a/hCaD_V2/test/cnf/unit1.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 0
diff --git a/hCaD_V2/test/cnf/unit2.sol b/hCaD_V2/test/cnf/unit2.sol
deleted file mode 100644
index 4904b64..0000000
--- a/hCaD_V2/test/cnf/unit2.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v 1 2 0
diff --git a/hCaD_V2/test/cnf/unit3.sol b/hCaD_V2/test/cnf/unit3.sol
deleted file mode 100644
index 8aafa17..0000000
--- a/hCaD_V2/test/cnf/unit3.sol
+++ /dev/null
@@ -1,2 +0,0 @@
-s SATISFIABLE
-v -1 -2 0
diff --git a/hCaD_V2/test/icnf/empty.icnf b/hCaD_V2/test/icnf/empty.icnf
deleted file mode 100644
index a2c9f08..0000000
--- a/hCaD_V2/test/icnf/empty.icnf
+++ /dev/null
@@ -1 +0,0 @@
-p inccnf
diff --git a/hCaD_V2/test/icnf/false.icnf b/hCaD_V2/test/icnf/false.icnf
deleted file mode 100644
index d3fb377..0000000
--- a/hCaD_V2/test/icnf/false.icnf
+++ /dev/null
@@ -1,2 +0,0 @@
-p inccnf
-0
diff --git a/hCaD_V2/test/icnf/makefile b/hCaD_V2/test/icnf/makefile
deleted file mode 100644
index 683eaf1..0000000
--- a/hCaD_V2/test/icnf/makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-# 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
deleted file mode 100644
index 082ef20..0000000
--- a/hCaD_V2/test/icnf/run.sh
+++ /dev/null
@@ -1,87 +0,0 @@
-#!/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
deleted file mode 100644
index e45ae58..0000000
--- a/hCaD_V2/test/icnf/two1.icnf
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index c03414c..0000000
--- a/hCaD_V2/test/icnf/two2.icnf
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index df8ff92..0000000
--- a/hCaD_V2/test/icnf/unit1.icnf
+++ /dev/null
@@ -1,3 +0,0 @@
-p inccnf
-1 0
-a -1 0
diff --git a/hCaD_V2/test/icnf/unit2.icnf b/hCaD_V2/test/icnf/unit2.icnf
deleted file mode 100644
index 3d550bd..0000000
--- a/hCaD_V2/test/icnf/unit2.icnf
+++ /dev/null
@@ -1,3 +0,0 @@
-p inccnf
-1 0
-a 1 0
diff --git a/hCaD_V2/test/makefile b/hCaD_V2/test/makefile
deleted file mode 100644
index 1c46862..0000000
--- a/hCaD_V2/test/makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 673bdd0..0000000
--- a/hCaD_V2/test/mbt/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index ccbb0f1..0000000
--- a/hCaD_V2/test/mbt/makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-# 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
deleted file mode 100644
index 33354c5..0000000
--- a/hCaD_V2/test/mbt/run.sh
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/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
deleted file mode 100644
index 475bdbd..0000000
--- a/hCaD_V2/test/trace/README.md
+++ /dev/null
@@ -1,6 +0,0 @@
-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
deleted file mode 100644
index 3f94d33..0000000
--- a/hCaD_V2/test/trace/makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-# 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
deleted file mode 100644
index 3a39f61..0000000
--- a/hCaD_V2/test/trace/reg0000.trace
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index f5cbf2d..0000000
--- a/hCaD_V2/test/trace/reg0001.trace
+++ /dev/null
@@ -1,4 +0,0 @@
-init
-solve
-solve
-reset
diff --git a/hCaD_V2/test/trace/reg0002.trace b/hCaD_V2/test/trace/reg0002.trace
deleted file mode 100644
index a593df6..0000000
--- a/hCaD_V2/test/trace/reg0002.trace
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index 0277dff..0000000
--- a/hCaD_V2/test/trace/reg0003.trace
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 8c2cb4d..0000000
--- a/hCaD_V2/test/trace/reg0004.trace
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index 2a395c9..0000000
--- a/hCaD_V2/test/trace/reg0005.trace
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 4618535..0000000
--- a/hCaD_V2/test/trace/reg0006.trace
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 46192ac..0000000
--- a/hCaD_V2/test/trace/reg0007.trace
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index 44f659e..0000000
--- a/hCaD_V2/test/trace/reg0008.trace
+++ /dev/null
@@ -1,39 +0,0 @@
-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
deleted file mode 100644
index 05f2574..0000000
--- a/hCaD_V2/test/trace/reg0009.trace
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index 2b5eb2f..0000000
--- a/hCaD_V2/test/trace/reg0010.trace
+++ /dev/null
@@ -1,10 +0,0 @@
-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
deleted file mode 100644
index 1b77b04..0000000
--- a/hCaD_V2/test/trace/reg0011.trace
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 144e424..0000000
--- a/hCaD_V2/test/trace/reg0012.trace
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index dbe86db..0000000
--- a/hCaD_V2/test/trace/reg0013.trace
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 4b90f8b..0000000
--- a/hCaD_V2/test/trace/reg0014.trace
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 79270d8..0000000
--- a/hCaD_V2/test/trace/reg0015.trace
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index 081d2a1..0000000
--- a/hCaD_V2/test/trace/reg0016.trace
+++ /dev/null
@@ -1,15 +0,0 @@
-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
deleted file mode 100644
index e8c2ce5..0000000
--- a/hCaD_V2/test/trace/reg0017.trace
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index 50844e6..0000000
--- a/hCaD_V2/test/trace/reg0018.trace
+++ /dev/null
@@ -1,23 +0,0 @@
-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
deleted file mode 100644
index a4e795a..0000000
--- a/hCaD_V2/test/trace/reg0019.trace
+++ /dev/null
@@ -1,23 +0,0 @@
-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
deleted file mode 100644
index ae393b2..0000000
--- a/hCaD_V2/test/trace/reg0020.trace
+++ /dev/null
@@ -1,16 +0,0 @@
-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
deleted file mode 100644
index 5de97c7..0000000
--- a/hCaD_V2/test/trace/reg0021.trace
+++ /dev/null
@@ -1,10 +0,0 @@
-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
deleted file mode 100644
index 61267ef..0000000
--- a/hCaD_V2/test/trace/reg0022.trace
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index f0d20ab..0000000
--- a/hCaD_V2/test/trace/reg0023.trace
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index 8e881cf..0000000
--- a/hCaD_V2/test/trace/reg0024.trace
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 65fb70f..0000000
--- a/hCaD_V2/test/trace/reg0025.trace
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index 118844d..0000000
--- a/hCaD_V2/test/trace/reg0026.trace
+++ /dev/null
@@ -1,23 +0,0 @@
-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
deleted file mode 100644
index 285e3a4..0000000
--- a/hCaD_V2/test/trace/reg0027.trace
+++ /dev/null
@@ -1,86 +0,0 @@
-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
deleted file mode 100644
index 4ef0f27..0000000
--- a/hCaD_V2/test/trace/reg0028.trace
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 66c787a..0000000
--- a/hCaD_V2/test/trace/reg0029.trace
+++ /dev/null
@@ -1,61 +0,0 @@
-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
deleted file mode 100644
index a874285..0000000
--- a/hCaD_V2/test/trace/reg0030.trace
+++ /dev/null
@@ -1,29 +0,0 @@
-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
deleted file mode 100644
index 3b48a9d..0000000
--- a/hCaD_V2/test/trace/reg0031.trace
+++ /dev/null
@@ -1,44 +0,0 @@
-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
deleted file mode 100644
index 9dfca82..0000000
--- a/hCaD_V2/test/trace/reg0032.trace
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index bd5d7cf..0000000
--- a/hCaD_V2/test/trace/reg0033.trace
+++ /dev/null
@@ -1,27 +0,0 @@
-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
deleted file mode 100644
index b0c03c4..0000000
--- a/hCaD_V2/test/trace/reg0034.trace
+++ /dev/null
@@ -1,10 +0,0 @@
-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
deleted file mode 100644
index 11e4bc1..0000000
--- a/hCaD_V2/test/trace/reg0035.trace
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 33888cc..0000000
--- a/hCaD_V2/test/trace/reg0036.trace
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 29fad88..0000000
--- a/hCaD_V2/test/trace/reg0037.trace
+++ /dev/null
@@ -1,21 +0,0 @@
-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
deleted file mode 100644
index 755067d..0000000
--- a/hCaD_V2/test/trace/reg0038.trace
+++ /dev/null
@@ -1,32 +0,0 @@
-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
deleted file mode 100644
index 4dfe510..0000000
--- a/hCaD_V2/test/trace/reg0039.trace
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index a561ea4..0000000
--- a/hCaD_V2/test/trace/reg0040.trace
+++ /dev/null
@@ -1,28 +0,0 @@
-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
deleted file mode 100644
index abdd7cc..0000000
--- a/hCaD_V2/test/trace/reg0041.trace
+++ /dev/null
@@ -1,62 +0,0 @@
-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
deleted file mode 100644
index 1542c6c..0000000
--- a/hCaD_V2/test/trace/reg0042.trace
+++ /dev/null
@@ -1,35 +0,0 @@
-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
deleted file mode 100644
index 2911e67..0000000
--- a/hCaD_V2/test/trace/reg0043.trace
+++ /dev/null
@@ -1,27 +0,0 @@
-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
deleted file mode 100644
index 1d11e20..0000000
--- a/hCaD_V2/test/trace/reg0044.trace
+++ /dev/null
@@ -1,10 +0,0 @@
-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
deleted file mode 100644
index b20a7c8..0000000
--- a/hCaD_V2/test/trace/reg0045.trace
+++ /dev/null
@@ -1,13 +0,0 @@
-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
deleted file mode 100644
index 0edc673..0000000
--- a/hCaD_V2/test/trace/reg0046.trace
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index f0caeab..0000000
--- a/hCaD_V2/test/trace/reg0047.trace
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index fdb6bb3..0000000
--- a/hCaD_V2/test/trace/reg0048.trace
+++ /dev/null
@@ -1,69 +0,0 @@
-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
deleted file mode 100644
index 05b066e..0000000
--- a/hCaD_V2/test/trace/reg0049.trace
+++ /dev/null
@@ -1,28 +0,0 @@
-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
deleted file mode 100644
index 05b066e..0000000
--- a/hCaD_V2/test/trace/reg0050.trace
+++ /dev/null
@@ -1,28 +0,0 @@
-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
deleted file mode 100644
index c70db59..0000000
--- a/hCaD_V2/test/trace/reg0051.trace
+++ /dev/null
@@ -1,39 +0,0 @@
-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
deleted file mode 100644
index f2945b1..0000000
--- a/hCaD_V2/test/trace/reg0052.trace
+++ /dev/null
@@ -1,67 +0,0 @@
-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
deleted file mode 100644
index 8acf01e..0000000
--- a/hCaD_V2/test/trace/reg0053.trace
+++ /dev/null
@@ -1,3 +0,0 @@
-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
deleted file mode 100644
index da9bd65..0000000
--- a/hCaD_V2/test/trace/reg0054.trace
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index 80ec7ae..0000000
--- a/hCaD_V2/test/trace/reg0055.trace
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index a725208..0000000
--- a/hCaD_V2/test/trace/reg0056.trace
+++ /dev/null
@@ -1,393 +0,0 @@
-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
deleted file mode 100644
index de15ef8..0000000
--- a/hCaD_V2/test/trace/run.sh
+++ /dev/null
@@ -1,96 +0,0 @@
-#!/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
deleted file mode 100644
index 84ea1a8..0000000
--- a/hCaD_V2/test/usage/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index f93291c..0000000
--- a/hCaD_V2/test/usage/makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-# 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
deleted file mode 100644
index a6977ba..0000000
--- a/hCaD_V2/test/usage/missing-clause.cnf
+++ /dev/null
@@ -1,2 +0,0 @@
-p cnf 1 0
-1 0
diff --git a/hCaD_V2/test/usage/relaxed-header.cnf b/hCaD_V2/test/usage/relaxed-header.cnf
deleted file mode 100644
index c5947ad..0000000
--- a/hCaD_V2/test/usage/relaxed-header.cnf
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index 03b1f1d..0000000
--- a/hCaD_V2/test/usage/run.sh
+++ /dev/null
@@ -1,149 +0,0 @@
-#!/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
deleted file mode 100644
index 1fbbf48..0000000
--- a/hCaD_V2/test/usage/variable-too-large.cnf
+++ /dev/null
@@ -1,2 +0,0 @@
-p cnf 0 1
-1 0
diff --git a/makefile b/makefile
index ffb90d0..dcc832b 100644
--- a/makefile
+++ b/makefile
@@ -2,13 +2,16 @@ SRCS = $(shell find . -maxdepth 1 -name "*.c*")
 
 BUILD_DIR = build/
 
+$(shell if [ ! -e $(BUILD_DIR) ];then mkdir -p $(BUILD_DIR); fi)
+
 OBJS = $(addprefix $(BUILD_DIR), $(addsuffix .o, $(basename $(SRCS))))
 
 EXEC = acec
 
-LIBS = -lgmp -Iopenf4 -Llib -lopenf4 -lcadical -LhCaD_V2/build/
+LIBS = -lgmp
+
+CXXFLAGS=-O3 -std=c++17
 
-CXXFLAGS=-O3 -IhCaD_V2 -std=c++17
 
 $(EXEC): $(OBJS)
 	$(CXX) -o $@ $^ $(CXXFLAGS) $(LIBS)
diff --git a/result.smt b/result.smt
deleted file mode 100644
index ef54b64..0000000
--- a/result.smt
+++ /dev/null
@@ -1,428 +0,0 @@
--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
deleted file mode 100644
index 4b43540..0000000
--- a/result.txt
+++ /dev/null
@@ -1,56 +0,0 @@
-  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
deleted file mode 100644
index 66f5305..0000000
--- a/smt.result
+++ /dev/null
@@ -1,591 +0,0 @@
-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
deleted file mode 100644
index 12d6482..0000000
--- a/sweep.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-#include "sweep.hpp"
-#include "src/cadical.hpp"
-#include "circuit.hpp"
-  
-extern "C" {
-    #include "aiger.h"
-}
-
-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;
-
-    used = new int[maxvar + 1];
-    C = new circuit[maxvar + 1];
-    memset(used, 0, (maxvar + 1) * sizeof(int));
-    sum_pos = new int[2 * maxvar + 2];
-    sum_neg = new int[2 * maxvar + 2];
-    memset(sum_pos, 0, sizeof(int) * (2 * maxvar + 2));
-    memset(sum_neg, 0, sizeof(int) * (2 * maxvar + 2));
-
-    for(int i=0; i<aig->num_ands; i++) {
-        auto gate = aig->ands[i];
-        int o  = aiger_lit2var(gate.lhs);
-        int i0 = aiger_lit2var(gate.rhs0);
-        int i1 = aiger_lit2var(gate.rhs1);
-        graph.add(i0, o, gate.rhs0 & 1);
-        graph.add(i1, o, gate.rhs1 & 1);
-
-        assert((gate.lhs & 1) == 0);
-        C[o].push(i0 * (gate.rhs0 & 1 ? -1 : 1));
-        C[o].push(i1 * (gate.rhs1 & 1 ? -1 : 1));
-    }
-    
-    // for (int i = 1; i <= maxvar; i++) {
-    //     circuit *c = &C[i];
-    //     if (!c->sz) continue; 
-    //     printf("%d = %s ( ", i, gate_type[c->type].c_str());
-    //     for (int j = 0; j < c->sz; j++) {
-    //         printf("%d ", c->to[j]);
-    //     }
-    //     puts(")");
-    // }
-    cal_topo_index();
-    return;
-
-    printf("c inputs: \nc ");
-    for(int i=0; i<aig->num_inputs; i++) {
-        printf("%d ", aig->inputs[i].lit);
-    }
-
-    printf("\nc outputs: \nc ");
-
-    for(int i=0; i<aig->num_outputs; i++) {
-        printf("%d ", aig->outputs[i].lit);
-    }
-    printf("\nc maxvar: \nc %d\n", maxvar);
-    // int x = det_v > 0 ? det_v : -det_v;
-    // if (x > maxvar) det_v = 0;
-    printf("assume:");
-    for (int i = 0; i < det_v_sz; i++) {
-        printf(" %d", det_v[i]);
-    }
-    puts("");
-}
-
-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());
-    identify();
-    //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
deleted file mode 100644
index 894c28f..0000000
--- a/sweep.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#ifndef sweep_hpp_INCLUDED
-#define sweep_hpp_INCLUDED
-#include <chrono>
-#include <bits/stdc++.h>
-#include <cstring>
-#include "vec.hpp"
-
-namespace CaDiCaL {
-    struct Solver;
-}
-struct aiger;
-struct circuit;
-
-
-class Graph {
-public:
-    struct Edge {
-        int from;
-        int to;
-        int neg;
-    };
-
-    std::vector<std::vector<Edge>> edge;
-    std::vector<std::vector<Edge>> redge;
-    void add(int u, int v, int w) {
-        edge.resize(std::max(std::max(u, v)+1, (int)edge.size()));
-        redge.resize(std::max(std::max(u, v)+1, (int)redge.size()));
-
-        edge[u].push_back(Edge{u, v, w});
-        redge[v].push_back(Edge{v, u, w});
-    }
-};
-
-
-class Sweep {
-public:
-    FILE* file;
-    Graph graph;
-
-    int maxvar, output;
-
-    int *used, *det_v, *seen, *sum_pos, *sum_neg, *del;
-    int det_v_sz = 0;
-    int rounds;
-
-    std::chrono::high_resolution_clock::time_point clk_st = std::chrono::high_resolution_clock::now();
-
-    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();
-
-    void aiger_preprocess();
-    
-    void cal_topo_index();
-
-    void propagate(int* input, int* result);
-
-    void circuit_propagate(int* input, int* result);
-    
-    void random_simulation();
-
-    void simulation();
-
-    bool check_var_equal(int x, int y, int assume);
-
-    bool check_constant(int x, int val);
-
-    void check_entire_problem(aiger* aig);
-
-    void check_with_SAT();
-
-    void identify();
-
-    bool match_xor(int x);
-
-    bool match_majority(int x);
-
-    void adjust_not();
-
-    void match_HA();
-
-    void match_FA();
-
-    bool line_positive(int to);
-
-    void recalculate_outs();
-
-    void to_multi_input_gates();
-
-    void simplify();
-
-    void miter();
-
-    void to_dot_graph(const char* filename, int end_point);
-
-    int  get_time();
-};
-
-
-#endif
\ No newline at end of file
diff --git a/test.smt b/test.smt
deleted file mode 100644
index 69a524a..0000000
--- a/test.smt
+++ /dev/null
@@ -1,5 +0,0 @@
-(declare-fun a () Bool)
-(declare-fun b () Bool)
-(assert (= 1 (+ a b)))
-(check-sat)
-(get-model)
diff --git a/vec.hpp b/vec.hpp
deleted file mode 100644
index 99b3136..0000000
--- a/vec.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#ifndef _vec_hpp_INCLUDED
-#define _vec_hpp_INCLUDED
-
-#include <cassert>
-#include <cstdio>
-#include <cstdlib>
-#include <cerrno>
-#include <cstddef>
-#include <cstring>
-#include <fstream>
-
-template<class T>
-class vec {
-     static inline int  imax   (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
-    static inline void nextCap(int &cap) { cap += ((cap >> 1) + 2) & ~1; }
-
-    public:
-        T* data;
-        int sz, cap;
-        vec()                   :  data(NULL), sz(0), cap(0) {}
-        vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
-        explicit vec(int size)  :  data(NULL), sz(0), cap(0) { growTo(size); }
-        ~vec()                                               { clear(true); }
-
-        operator T*      (void)         { return data; }
-        
-        int     size     (void) const   { return sz;   }
-        int     capacity (void) const   { return cap;  }
-        void    capacity (int min_cap);
-
-        void    setsize  (int v)        { sz = v;} 
-        void    push  (void)            { if (sz == cap) capacity(sz + 1); new (&data[sz]) T(); sz++; }
-        void    push   (const T& elem)  { if (sz == cap) capInc(sz + 1); data[sz++] = elem; }
-        void    push_  (const T& elem)  { assert(sz < cap); data[sz++] = elem; }
-        void    pop    (void)           { assert(sz > 0), sz--, data[sz].~T(); } 
-        void    copyTo (vec<T>& copy)   { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
-        
-        void    growTo   (int size);
-        void    growTo   (int size, const T& pad);
-        void    clear    (bool dealloc = false);
-        void    capInc   (int to_cap);
-
-
-        T&       operator [] (int index)       { return data[index]; }
-        const T& operator [] (int index) const { return data[index]; }
-
-        T&       last        (void)            { return data[sz - 1]; }
-        const T& last        (void)      const { return data[sz - 1]; }
-                    
-};
-
-
-class OutOfMemoryException{};
-
-template<class T>
-void vec<T>::clear(bool dealloc) {
-    if (data != NULL) {
-        sz = 0;
-        if (dealloc) free(data), data = NULL, cap = 0;
-    }
-}
-
-template<class T>
-void vec<T>::capInc(int to_cap) {
-    if (cap >= to_cap) return;
-    int add = imax((to_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1); 
-    if (add > __INT_MAX__ - cap || ((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM)
-        throw OutOfMemoryException();
-}
-
-template<class T>
-void vec<T>::capacity(int min_cap) {
-    if (cap >= min_cap) return;
-    int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
-    if (add > __INT_MAX__ - cap || ((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM)
-        throw OutOfMemoryException();
- }
-
-template<class T>
-void vec<T>::growTo(int size) {
-    if (sz >= size) return;
-    capInc(size);
-    for (int i = 0; i < sz; i++) new (&data[i]) T();
-    sz = size;
-}
-
-template<class T>
-void vec<T>::growTo(int size, const T& pad) {
-    if (sz >= size) return;
-    capacity(size);
-    for (int i = sz; i < size; i++) data[i] = pad;
-    sz = size; }
-
-
-#endif
\ No newline at end of file